/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc

Bug Summary

File:	build/gcc/tree-cfg.cc
Warning:	line 1062, column 2 Argument to free() is the address of the local variable 'dispatcher_bb_array', which is not memory allocated by malloc()
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name tree-cfg.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -resource-dir /usr/lib64/clang/15.0.7 -D IN_GCC -D HAVE_CONFIG_H -I . -I . -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/. -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../include/c++/13/backward -internal-isystem /usr/lib64/clang/15.0.7/include -internal-isystem /usr/local/include -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/13/../../../../x86_64-suse-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir=/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2023-03-27-141847-20772-1/report-Qc28yj.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc
1/* Control flow functions for trees.
 Copyright (C) 2001-2023 Free Software Foundation, Inc.
 Contributed by Diego Novillo <dnovillo@redhat.com>

5This file is part of GCC.

7GCC is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 3, or (at your option)
10any later version.

12GCC is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15GNU General Public License for 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#include "config.h"
22#include "system.h"
23#include "coretypes.h"
24#include "backend.h"
25#include "target.h"
26#include "rtl.h"
27#include "tree.h"
28#include "gimple.h"
29#include "cfghooks.h"
30#include "tree-pass.h"
31#include "ssa.h"
32#include "cgraph.h"
33#include "gimple-pretty-print.h"
34#include "diagnostic-core.h"
35#include "fold-const.h"
36#include "trans-mem.h"
37#include "stor-layout.h"
38#include "print-tree.h"
39#include "cfganal.h"
40#include "gimple-iterator.h"
41#include "gimple-fold.h"
42#include "tree-eh.h"
43#include "gimplify-me.h"
44#include "gimple-walk.h"
45#include "tree-cfg.h"
46#include "tree-ssa-loop-manip.h"
47#include "tree-ssa-loop-niter.h"
48#include "tree-into-ssa.h"
49#include "tree-dfa.h"
50#include "tree-ssa.h"
51#include "except.h"
52#include "cfgloop.h"
53#include "tree-ssa-propagate.h"
54#include "value-prof.h"
55#include "tree-inline.h"
56#include "tree-ssa-live.h"
57#include "tree-ssa-dce.h"
58#include "omp-general.h"
59#include "omp-expand.h"
60#include "tree-cfgcleanup.h"
61#include "gimplify.h"
62#include "attribs.h"
63#include "selftest.h"
64#include "opts.h"
65#include "asan.h"
66#include "profile.h"
67#include "sreal.h"

69/* This file contains functions for building the Control Flow Graph (CFG)
 for a function tree.  */

72/* Local declarations.  */

74/* Initial capacity for the basic block array.  */
75static const int initial_cfg_capacity = 20;

77/* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
 which use a particular edge.  The CASE_LABEL_EXPRs are chained together
 via their CASE_CHAIN field, which we clear after we're done with the
 hash table to prevent problems with duplication of GIMPLE_SWITCHes.

 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
 update the case vector in response to edge redirections.

 Right now this table is set up and torn down at key points in the
 compilation process.  It would be nice if we could make the table
 more persistent.  The key is getting notification of changes to
 the CFG (particularly edge removal, creation and redirection).  */

90static hash_map<edge, tree> *edge_to_cases;

92/* If we record edge_to_cases, this bitmap will hold indexes
 of basic blocks that end in a GIMPLE_SWITCH which we touched
 due to edge manipulations.  */

96static bitmap touched_switch_bbs;

98/* OpenMP region idxs for blocks during cfg pass.  */
99static vec<int> bb_to_omp_idx;

101/* CFG statistics.  */
102struct cfg_stats_d
103{
long num_merged_labels;
105};

107static struct cfg_stats_d cfg_stats;

109/* Data to pass to replace_block_vars_by_duplicates_1.  */
110struct replace_decls_d
111{
hash_map<tree, tree> *vars_map;
tree to_context;
114};

116/* Hash table to store last discriminator assigned for each locus.  */
117struct locus_discrim_map
118{
int location_line;
int discriminator;
121};

123/* Hashtable helpers.  */

125struct locus_discrim_hasher : free_ptr_hash <locus_discrim_map>
126{
static inline hashval_t hash (const locus_discrim_map *);
static inline bool equal (const locus_discrim_map *,
	    const locus_discrim_map *);
130};

132/* Trivial hash function for a location_t.  ITEM is a pointer to
 a hash table entry that maps a location_t to a discriminator.  */

135inline hashval_t
136locus_discrim_hasher::hash (const locus_discrim_map *item)
137{
return item->location_line;
139}

141/* Equality function for the locus-to-discriminator map.  A and B
 point to the two hash table entries to compare.  */

144inline bool
145locus_discrim_hasher::equal (const locus_discrim_map *a,
	     const locus_discrim_map *b)
147{
return a->location_line == b->location_line;
149}

151static hash_table<locus_discrim_hasher> *discriminator_per_locus;

153/* Basic blocks and flowgraphs.  */
154static void make_blocks (gimple_seq);

156/* Edges.  */
157static void make_edges (void);
158static void assign_discriminators (void);
159static void make_cond_expr_edges (basic_block);
160static void make_gimple_switch_edges (gswitch *, basic_block);
161static bool make_goto_expr_edges (basic_block);
162static void make_gimple_asm_edges (basic_block);
163static edge gimple_redirect_edge_and_branch (edge, basic_block);
164static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);

166/* Various helpers.  */
167static inline bool stmt_starts_bb_p (gimple *, gimple *);
168static int gimple_verify_flow_info (void);
169static void gimple_make_forwarder_block (edge);
170static gimple *first_non_label_stmt (basic_block);
171static bool verify_gimple_transaction (gtransaction *);
172static bool call_can_make_abnormal_goto (gimple *);

174/* Flowgraph optimization and cleanup.  */
175static void gimple_merge_blocks (basic_block, basic_block);
176static bool gimple_can_merge_blocks_p (basic_block, basic_block);
177static void remove_bb (basic_block);
178static edge find_taken_edge_computed_goto (basic_block, tree);
179static edge find_taken_edge_cond_expr (const gcond *, tree);

181void
182init_empty_tree_cfg_for_function (struct function *fn)
183{
/* Initialize the basic block array.  */
init_flow (fn);
profile_status_for_fn (fn)((fn)->cfg->x_profile_status) = PROFILE_ABSENT;
n_basic_blocks_for_fn (fn)((fn)->cfg->x_n_basic_blocks) = NUM_FIXED_BLOCKS(2);
last_basic_block_for_fn (fn)((fn)->cfg->x_last_basic_block) = NUM_FIXED_BLOCKS(2);
vec_safe_grow_cleared (basic_block_info_for_fn (fn)((fn)->cfg->x_basic_block_info),
	 initial_cfg_capacity, true);

/* Build a mapping of labels to their associated blocks.  */
vec_safe_grow_cleared (label_to_block_map_for_fn (fn)((fn)->cfg->x_label_to_block_map),
	 initial_cfg_capacity, true);

SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn))((*((fn)->cfg->x_basic_block_info))[((0))] = (((fn)->
cfg->x_entry_block_ptr)));
SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn))((*((fn)->cfg->x_basic_block_info))[((1))] = (((fn)->
cfg->x_exit_block_ptr)));

ENTRY_BLOCK_PTR_FOR_FN (fn)((fn)->cfg->x_entry_block_ptr)->next_bb
  = EXIT_BLOCK_PTR_FOR_FN (fn)((fn)->cfg->x_exit_block_ptr);
EXIT_BLOCK_PTR_FOR_FN (fn)((fn)->cfg->x_exit_block_ptr)->prev_bb
  = ENTRY_BLOCK_PTR_FOR_FN (fn)((fn)->cfg->x_entry_block_ptr);
203}

205void
206init_empty_tree_cfg (void)
207{
init_empty_tree_cfg_for_function (cfun(cfun + 0));
209}

211/*---------------------------------------------------------------------------
	      Create basic blocks
213---------------------------------------------------------------------------*/

215/* Entry point to the CFG builder for trees.  SEQ is the sequence of
 statements to be added to the flowgraph.  */

218static void
219build_gimple_cfg (gimple_seq seq)
220{
/* Register specific gimple functions.  */
gimple_register_cfg_hooks ();

memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));

init_empty_tree_cfg ();

make_blocks (seq);

/* Make sure there is always at least one block, even if it's empty.  */
if (n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks) == NUM_FIXED_BLOCKS(2))
3
←
Assuming field 'x_n_basic_blocks' is not equal to NUM_FIXED_BLOCKS→
4
←
Taking false branch→
  create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));

/* Adjust the size of the array.  */
if (basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info)->length ()
5
←
Assuming the condition is false→
6
←
Taking false branch→
    < (size_t) n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks))
  vec_safe_grow_cleared (basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info),
	   n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks));

/* To speed up statement iterator walks, we first purge dead labels.  */
cleanup_dead_labels ();

/* Group case nodes to reduce the number of edges.
   We do this after cleaning up dead labels because otherwise we miss
   a lot of obvious case merging opportunities.  */
group_case_labels ();

/* Create the edges of the flowgraph.  */
discriminator_per_locus = new hash_table<locus_discrim_hasher> (13);
make_edges ();
7
←
Calling 'make_edges'→
assign_discriminators ();
cleanup_dead_labels ();
delete discriminator_per_locus;
discriminator_per_locus = NULLnullptr;
255}

257/* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
 them and propagate the information to LOOP.  We assume that the annotations
 come immediately before the condition in BB, if any.  */

261static void
262replace_loop_annotate_in_block (basic_block bb, class loop *loop)
263{
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gimple *stmt = gsi_stmt (gsi);

if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
  return;

for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
  {
    stmt = gsi_stmt (gsi);
    if (gimple_code (stmt) != GIMPLE_CALL)
break;
    if (!gimple_call_internal_p (stmt)
 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
break;

    switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
{
case annot_expr_ivdep_kind:
 loop->safelen = INT_MAX2147483647;
 break;
case annot_expr_unroll_kind:
 loop->unroll
   = (unsigned short) tree_to_shwi (gimple_call_arg (stmt, 2));
 cfun(cfun + 0)->has_unroll = true;
 break;
case annot_expr_no_vector_kind:
 loop->dont_vectorize = true;
 break;
case annot_expr_vector_kind:
 loop->force_vectorize = true;
 cfun(cfun + 0)->has_force_vectorize_loops = true;
 break;
case annot_expr_parallel_kind:
 loop->can_be_parallel = true;
 loop->safelen = INT_MAX2147483647;
 break;
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 301, __FUNCTION__));
}

    stmt = gimple_build_assign (gimple_call_lhs (stmt),
		  gimple_call_arg (stmt, 0));
    gsi_replace (&gsi, stmt, true);
  }
308}

310/* Look for ANNOTATE calls with loop annotation kind; if found, remove
 them and propagate the information to the loop.  We assume that the
 annotations come immediately before the condition of the loop.  */

314static void
315replace_loop_annotate (void)
316{
basic_block bb;
gimple_stmt_iterator gsi;
gimple *stmt;

for (auto loop : loops_list (cfun(cfun + 0), 0))
  {
    /* First look into the header.  */
    replace_loop_annotate_in_block (loop->header, loop);

    /* Then look into the latch, if any.  */
    if (loop->latch)
replace_loop_annotate_in_block (loop->latch, loop);

    /* Push the global flag_finite_loops state down to individual loops.  */
    loop->finite_p = flag_finite_loopsglobal_options.x_flag_finite_loops;
  }

/* Remove IFN_ANNOTATE.  Safeguard for the case loop->latch == NULL.  */
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)
  {
    for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
{
 stmt = gsi_stmt (gsi);
 if (gimple_code (stmt) != GIMPLE_CALL)
   continue;
 if (!gimple_call_internal_p (stmt)
     || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
   continue;

 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
   {
   case annot_expr_ivdep_kind:
   case annot_expr_unroll_kind:
   case annot_expr_no_vector_kind:
   case annot_expr_vector_kind:
   case annot_expr_parallel_kind:
     break;
   default:
     gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 355, __FUNCTION__));
   }

 warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
 stmt = gimple_build_assign (gimple_call_lhs (stmt),
		      gimple_call_arg (stmt, 0));
 gsi_replace (&gsi, stmt, true);
}
  }
364}

366static unsigned int
367execute_build_cfg (void)
368{
gimple_seq body = gimple_body (current_function_decl);

build_gimple_cfg (body);
2
←
Calling 'build_gimple_cfg'→
gimple_set_body (current_function_decl, NULLnullptr);
if (dump_file && (dump_flags & TDF_DETAILS))
  {
    fprintf (dump_file, "Scope blocks:\n");
    dump_scope_blocks (dump_file, dump_flags);
  }
cleanup_tree_cfg ();

bb_to_omp_idx.release ();

loop_optimizer_init (AVOID_CFG_MODIFICATIONS(LOOPS_MAY_HAVE_MULTIPLE_LATCHES));
replace_loop_annotate ();
return 0;
385}

387namespace {

389const pass_data pass_data_build_cfg =
390{
GIMPLE_PASS, /* type */
"cfg", /* name */
OPTGROUP_NONE, /* optinfo_flags */
TV_TREE_CFG, /* tv_id */
PROP_gimple_leh(1 << 2), /* properties_required */
( PROP_cfg(1 << 3) | PROP_loops(1 << 11) ), /* properties_provided */
0, /* properties_destroyed */
0, /* todo_flags_start */
0, /* todo_flags_finish */
400};

402class pass_build_cfg : public gimple_opt_pass
403{
404public:
pass_build_cfg (gcc::context *ctxt)
  : gimple_opt_pass (pass_data_build_cfg, ctxt)
{}

/* opt_pass methods: */
unsigned int execute (function *) final override
{
  return execute_build_cfg ();
1
Calling 'execute_build_cfg'→
}

415}; // class pass_build_cfg

417} // anon namespace

419gimple_opt_pass *
420make_pass_build_cfg (gcc::context *ctxt)
421{
return new pass_build_cfg (ctxt);
423}


426/* Return true if T is a computed goto.  */

428bool
429computed_goto_p (gimple *t)
430{
return (gimple_code (t) == GIMPLE_GOTO
 && TREE_CODE (gimple_goto_dest (t))((enum tree_code) (gimple_goto_dest (t))->base.code) != LABEL_DECL);
433}

435/* Returns true if the sequence of statements STMTS only contains
 a call to __builtin_unreachable ().  */

438bool
439gimple_seq_unreachable_p (gimple_seq stmts)
440{
if (stmts == NULLnullptr
    /* Return false if -fsanitize=unreachable, we don't want to
optimize away those calls, but rather turn them into
__ubsan_handle_builtin_unreachable () or __builtin_trap ()
later.  */
    || sanitize_flags_p (SANITIZE_UNREACHABLE))
  return false;

gimple_stmt_iterator gsi = gsi_last (stmts);

if (!gimple_call_builtin_p (gsi_stmt (gsi), BUILT_IN_UNREACHABLE))
  return false;

for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
  {
    gimple *stmt = gsi_stmt (gsi);
    if (gimple_code (stmt) != GIMPLE_LABEL
 && !is_gimple_debug (stmt)
 && !gimple_clobber_p (stmt))
    return false;
  }
return true;
463}

465/* Returns true for edge E where e->src ends with a GIMPLE_COND and
 the other edge points to a bb with just __builtin_unreachable ().
 I.e. return true for C->M edge in:
 <bb C>:
 ...
 if (something)
   goto <bb N>;
 else
   goto <bb M>;
 <bb N>:
 __builtin_unreachable ();
 <bb M>:  */

478bool
479assert_unreachable_fallthru_edge_p (edge e)
480{
basic_block pred_bb = e->src;
gimple *last = last_stmt (pred_bb);
if (last && gimple_code (last) == GIMPLE_COND)
  {
    basic_block other_bb = EDGE_SUCC (pred_bb, 0)(*(pred_bb)->succs)[(0)]->dest;
    if (other_bb == e->dest)
other_bb = EDGE_SUCC (pred_bb, 1)(*(pred_bb)->succs)[(1)]->dest;
    if (EDGE_COUNT (other_bb->succs)vec_safe_length (other_bb->succs) == 0)
return gimple_seq_unreachable_p (bb_seq (other_bb));
  }
return false;
492}


495/* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
 could alter control flow except via eh. We initialize the flag at
 CFG build time and only ever clear it later.  */

499static void
500gimple_call_initialize_ctrl_altering (gimple *stmt)
501{
int flags = gimple_call_flags (stmt);

/* A call alters control flow if it can make an abnormal goto.  */
if (call_can_make_abnormal_goto (stmt)
    /* A call also alters control flow if it does not return.  */
    || flags & ECF_NORETURN(1 << 3)
    /* TM ending statements have backedges out of the transaction.
Return true so we split the basic block containing them.
Note that the TM_BUILTIN test is merely an optimization.  */
    || ((flags & ECF_TM_BUILTIN(1 << 13))
 && is_tm_ending_fndecl (gimple_call_fndecl (stmt)))
    /* BUILT_IN_RETURN call is same as return statement.  */
    || gimple_call_builtin_p (stmt, BUILT_IN_RETURN)
    /* IFN_UNIQUE should be the last insn, to make checking for it
as cheap as possible.  */
    || (gimple_call_internal_p (stmt)
 && gimple_call_internal_unique_p (stmt)))
  gimple_call_set_ctrl_altering (stmt, true);
else
  gimple_call_set_ctrl_altering (stmt, false);
522}


525/* Insert SEQ after BB and build a flowgraph.  */

527static basic_block
528make_blocks_1 (gimple_seq seq, basic_block bb)
529{
gimple_stmt_iterator i = gsi_start (seq);
gimple *stmt = NULLnullptr;
gimple *prev_stmt = NULLnullptr;
bool start_new_block = true;
bool first_stmt_of_seq = true;

while (!gsi_end_p (i))
  {
    /* PREV_STMT should only be set to a debug stmt if the debug
stmt is before nondebug stmts.  Once stmt reaches a nondebug
nonlabel, prev_stmt will be set to it, so that
stmt_starts_bb_p will know to start a new block if a label is
found.  However, if stmt was a label after debug stmts only,
keep the label in prev_stmt even if we find further debug
stmts, for there may be other labels after them, and they
should land in the same block.  */
    if (!prev_stmt || !stmt || !is_gimple_debug (stmt))
prev_stmt = stmt;
    stmt = gsi_stmt (i);

    if (stmt && is_gimple_call (stmt))
gimple_call_initialize_ctrl_altering (stmt);

    /* If the statement starts a new basic block or if we have determined
in a previous pass that we need to create a new block for STMT, do
so now.  */
    if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
{
 if (!first_stmt_of_seq)
   gsi_split_seq_before (&i, &seq);
 bb = create_basic_block (seq, bb);
 start_new_block = false;
 prev_stmt = NULLnullptr;
}

    /* Now add STMT to BB and create the subgraphs for special statement
codes.  */
    gimple_set_bb (stmt, bb);

    /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
next iteration.  */
    if (stmt_ends_bb_p (stmt))
{
 /* If the stmt can make abnormal goto use a new temporary
    for the assignment to the LHS.  This makes sure the old value
    of the LHS is available on the abnormal edge.  Otherwise
    we will end up with overlapping life-ranges for abnormal
    SSA names.  */
 if (gimple_has_lhs (stmt)
     && stmt_can_make_abnormal_goto (stmt)
     && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))((contains_struct_check ((gimple_get_lhs (stmt)), (TS_TYPED),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 580, __FUNCTION__))->typed.type)))
   {
     tree lhs = gimple_get_lhs (stmt);
     tree tmp = create_tmp_var (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 583, __FUNCTION__))->typed.type));
     gimple *s = gimple_build_assign (lhs, tmp);
     gimple_set_location (s, gimple_location (stmt));
     gimple_set_block (s, gimple_block (stmt));
     gimple_set_lhs (stmt, tmp);
     gsi_insert_after (&i, s, GSI_SAME_STMT);
   }
 start_new_block = true;
}

    gsi_next (&i);
    first_stmt_of_seq = false;
  }
return bb;
597}

599/* Build a flowgraph for the sequence of stmts SEQ.  */

601static void
602make_blocks (gimple_seq seq)
603{
/* Look for debug markers right before labels, and move the debug
   stmts after the labels.  Accepting labels among debug markers
   adds no value, just complexity; if we wanted to annotate labels
   with view numbers (so sequencing among markers would matter) or
   somesuch, we're probably better off still moving the labels, but
   adding other debug annotations in their original positions or
   emitting nonbind or bind markers associated with the labels in
   the original position of the labels.

   Moving labels would probably be simpler, but we can't do that:
   moving labels assigns label ids to them, and doing so because of
   debug markers makes for -fcompare-debug and possibly even codegen
   differences.  So, we have to move the debug stmts instead.  To
   that end, we scan SEQ backwards, marking the position of the
   latest (earliest we find) label, and moving debug stmts that are
   not separated from it by nondebug nonlabel stmts after the
   label.  */
if (MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p)
  {
    gimple_stmt_iterator label = gsi_none ();

    for (gimple_stmt_iterator i = gsi_last (seq); !gsi_end_p (i); gsi_prev (&i))
{
 gimple *stmt = gsi_stmt (i);

 /* If this is the first label we encounter (latest in SEQ)
    before nondebug stmts, record its position.  */
 if (is_a <glabel *> (stmt))
   {
     if (gsi_end_p (label))
label = i;
     continue;
   }

 /* Without a recorded label position to move debug stmts to,
    there's nothing to do.  */
 if (gsi_end_p (label))
   continue;

 /* Move the debug stmt at I after LABEL.  */
 if (is_gimple_debug (stmt))
   {
     gcc_assert (gimple_debug_nonbind_marker_p (stmt))((void)(!(gimple_debug_nonbind_marker_p (stmt)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 646, __FUNCTION__), 0 : 0));
     /* As STMT is removed, I advances to the stmt after
 STMT, so the gsi_prev in the for "increment"
 expression gets us to the stmt we're to visit after
 STMT.  LABEL, however, would advance to the moved
 stmt if we passed it to gsi_move_after, so pass it a
 copy instead, so as to keep LABEL pointing to the
 LABEL.  */
     gimple_stmt_iterator copy = label;
     gsi_move_after (&i, &copy);
     continue;
   }

 /* There aren't any (more?) debug stmts before label, so
    there isn't anything else to move after it.  */
 label = gsi_none ();
}
  }

make_blocks_1 (seq, ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));
666}

668/* Create and return a new empty basic block after bb AFTER.  */

670static basic_block
671create_bb (void *h, void *e, basic_block after)
672{
basic_block bb;

gcc_assert (!e)((void)(!(!e) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 675, __FUNCTION__), 0 : 0));

/* Create and initialize a new basic block.  Since alloc_block uses
   GC allocation that clears memory to allocate a basic block, we do
   not have to clear the newly allocated basic block here.  */
bb = alloc_block ();

bb->index = last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block);
bb->flags = BB_NEW;
set_bb_seq (bb, h ? (gimple_seq) h : NULLnullptr);

/* Add the new block to the linked list of blocks.  */
link_block (bb, after);

/* Grow the basic block array if needed.  */
if ((size_t) last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block)
    == basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info)->length ())
  vec_safe_grow_cleared (basic_block_info_for_fn (cfun)(((cfun + 0))->cfg->x_basic_block_info),
	   last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block) + 1);

/* Add the newly created block to the array.  */
SET_BASIC_BLOCK_FOR_FN (cfun, last_basic_block_for_fn (cfun), bb)((*(((cfun + 0))->cfg->x_basic_block_info))[((((cfun + 0
))->cfg->x_last_basic_block))] = (bb));

n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks)++;
last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block)++;

return bb;
702}


705/*---------------------------------------------------------------------------
		 Edge creation
707---------------------------------------------------------------------------*/

709/* If basic block BB has an abnormal edge to a basic block
 containing IFN_ABNORMAL_DISPATCHER internal call, return
 that the dispatcher's basic block, otherwise return NULL.  */

713basic_block
714get_abnormal_succ_dispatcher (basic_block bb)
715{
edge e;
edge_iterator ei;

FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
  if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
    {
gimple_stmt_iterator gsi
 = gsi_start_nondebug_after_labels_bb (e->dest);
gimple *g = gsi_stmt (gsi);
if (g && gimple_call_internal_p (g, IFN_ABNORMAL_DISPATCHER))
 return e->dest;
    }
return NULLnullptr;
729}

731/* Helper function for make_edges.  Create a basic block with
 with ABNORMAL_DISPATCHER internal call in it if needed, and
 create abnormal edges from BBS to it and from it to FOR_BB
 if COMPUTED_GOTO is false, otherwise factor the computed gotos.  */

736static void
737handle_abnormal_edges (basic_block *dispatcher_bbs, basic_block for_bb,
       auto_vec<basic_block> *bbs, bool computed_goto)
739{
basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
unsigned int idx = 0;
basic_block bb;
bool inner = false;

if (!bb_to_omp_idx.is_empty ())
  {
    dispatcher = dispatcher_bbs + 2 * bb_to_omp_idx[for_bb->index];
    if (bb_to_omp_idx[for_bb->index] != 0)
inner = true;
  }

/* If the dispatcher has been created already, then there are basic
   blocks with abnormal edges to it, so just make a new edge to
   for_bb.  */
if (*dispatcher == NULLnullptr)
  {
    /* Check if there are any basic blocks that need to have
abnormal edges to this dispatcher.  If there are none, return
early.  */
    if (bb_to_omp_idx.is_empty ())
{
 if (bbs->is_empty ())
   return;
}
    else
{
 FOR_EACH_VEC_ELT (*bbs, idx, bb)for (idx = 0; (*bbs).iterate ((idx), &(bb)); ++(idx))
   if (bb_to_omp_idx[bb->index] == bb_to_omp_idx[for_bb->index])
     break;
 if (bb == NULLnullptr)
   return;
}

    /* Create the dispatcher bb.  */
    *dispatcher = create_basic_block (NULLnullptr, for_bb);
    if (computed_goto)
{
 /* Factor computed gotos into a common computed goto site.  Also
    record the location of that site so that we can un-factor the
    gotos after we have converted back to normal form.  */
 gimple_stmt_iterator gsi = gsi_start_bb (*dispatcher);

 /* Create the destination of the factored goto.  Each original
    computed goto will put its desired destination into this
    variable and jump to the label we create immediately below.  */
 tree var = create_tmp_var (ptr_type_nodeglobal_trees[TI_PTR_TYPE], "gotovar");

 /* Build a label for the new block which will contain the
    factored computed goto.  */
 tree factored_label_decl
   = create_artificial_label (UNKNOWN_LOCATION((location_t) 0));
 gimple *factored_computed_goto_label
   = gimple_build_label (factored_label_decl);
 gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);

 /* Build our new computed goto.  */
 gimple *factored_computed_goto = gimple_build_goto (var);
 gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);

 FOR_EACH_VEC_ELT (*bbs, idx, bb)for (idx = 0; (*bbs).iterate ((idx), &(bb)); ++(idx))
   {
     if (!bb_to_omp_idx.is_empty ()
  && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
continue;

     gsi = gsi_last_bb (bb);
     gimple *last = gsi_stmt (gsi);

     gcc_assert (computed_goto_p (last))((void)(!(computed_goto_p (last)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 809, __FUNCTION__), 0 : 0));

     /* Copy the original computed goto's destination into VAR.  */
     gimple *assignment
= gimple_build_assign (var, gimple_goto_dest (last));
     gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);

     edge e = make_edge (bb, *dispatcher, EDGE_FALLTHRU);
     e->goto_locus = gimple_location (last);
     gsi_remove (&gsi, true);
   }
}
    else
{
 tree arg = inner ? boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE] : boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE];
 gcall *g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
				 1, arg);
 gimple_call_set_ctrl_altering (g, true);
 gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
 gsi_insert_after (&gsi, g, GSI_NEW_STMT);

 /* Create predecessor edges of the dispatcher.  */
 FOR_EACH_VEC_ELT (*bbs, idx, bb)for (idx = 0; (*bbs).iterate ((idx), &(bb)); ++(idx))
   {
     if (!bb_to_omp_idx.is_empty ()
  && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
continue;
     make_edge (bb, *dispatcher, EDGE_ABNORMAL);
   }
}
  }

make_edge (*dispatcher, for_bb, EDGE_ABNORMAL);
842}

844/* Creates outgoing edges for BB.  Returns 1 when it ends with an
 computed goto, returns 2 when it ends with a statement that
 might return to this function via an nonlocal goto, otherwise
 return 0.  Updates *PCUR_REGION with the OMP region this BB is in.  */

849static int
850make_edges_bb (basic_block bb, struct omp_region **pcur_region, int *pomp_index)
851{
gimple *last = last_stmt (bb);
bool fallthru = false;
int ret = 0;

if (!last)
  return ret;

switch (gimple_code (last))
  {
  case GIMPLE_GOTO:
    if (make_goto_expr_edges (bb))
ret = 1;
    fallthru = false;
    break;
  case GIMPLE_RETURN:
    {
edge e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), 0);
e->goto_locus = gimple_location (last);
fallthru = false;
    }
    break;
  case GIMPLE_COND:
    make_cond_expr_edges (bb);
    fallthru = false;
    break;
  case GIMPLE_SWITCH:
    make_gimple_switch_edges (as_a <gswitch *> (last), bb);
    fallthru = false;
    break;
  case GIMPLE_RESX:
    make_eh_edges (last);
    fallthru = false;
    break;
  case GIMPLE_EH_DISPATCH:
    fallthru = make_eh_dispatch_edges (as_a <geh_dispatch *> (last));
    break;

  case GIMPLE_CALL:
    /* If this function receives a nonlocal goto, then we need to
make edges from this call site to all the nonlocal goto
handlers.  */
    if (stmt_can_make_abnormal_goto (last))
ret = 2;

    /* If this statement has reachable exception handlers, then
create abnormal edges to them.  */
    make_eh_edges (last);

    /* BUILTIN_RETURN is really a return statement.  */
    if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
{
 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr), 0);
 fallthru = false;
}
    /* Some calls are known not to return.  */
    else
fallthru = !gimple_call_noreturn_p (last);
    break;

  case GIMPLE_ASSIGN:
    /* A GIMPLE_ASSIGN may throw internally and thus be considered
control-altering.  */
    if (is_ctrl_altering_stmt (last))
make_eh_edges (last);
    fallthru = true;
    break;

  case GIMPLE_ASM:
    make_gimple_asm_edges (bb);
    fallthru = true;
    break;

  CASE_GIMPLE_OMPcase GIMPLE_OMP_PARALLEL: case GIMPLE_OMP_TASK: case GIMPLE_OMP_FOR
: case GIMPLE_OMP_SECTIONS: case GIMPLE_OMP_SECTIONS_SWITCH: case
 GIMPLE_OMP_SINGLE: case GIMPLE_OMP_TARGET: case GIMPLE_OMP_TEAMS
: case GIMPLE_OMP_SCOPE: case GIMPLE_OMP_SECTION: case GIMPLE_OMP_MASTER
: case GIMPLE_OMP_MASKED: case GIMPLE_OMP_TASKGROUP: case GIMPLE_OMP_ORDERED
: case GIMPLE_OMP_CRITICAL: case GIMPLE_OMP_SCAN: case GIMPLE_OMP_RETURN
: case GIMPLE_OMP_ATOMIC_LOAD: case GIMPLE_OMP_ATOMIC_STORE: case
 GIMPLE_OMP_CONTINUE:
    fallthru = omp_make_gimple_edges (bb, pcur_region, pomp_index);
    break;

  case GIMPLE_TRANSACTION:
    {
      gtransaction *txn = as_a <gtransaction *> (last);
tree label1 = gimple_transaction_label_norm (txn);
tree label2 = gimple_transaction_label_uninst (txn);

if (label1)
 make_edge (bb, label_to_block (cfun(cfun + 0), label1), EDGE_FALLTHRU);
if (label2)
 make_edge (bb, label_to_block (cfun(cfun + 0), label2),
     EDGE_TM_UNINSTRUMENTED | (label1 ? 0 : EDGE_FALLTHRU));

tree label3 = gimple_transaction_label_over (txn);
if (gimple_transaction_subcode (txn)
   & (GTMA_HAVE_ABORT(1u << 2) | GTMA_IS_OUTER(1u << 0)))
 make_edge (bb, label_to_block (cfun(cfun + 0), label3), EDGE_TM_ABORT);

fallthru = false;
    }
    break;

  default:
    gcc_assert (!stmt_ends_bb_p (last))((void)(!(!stmt_ends_bb_p (last)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 950, __FUNCTION__), 0 : 0));
    fallthru = true;
    break;
  }

if (fallthru)
  make_edge (bb, bb->next_bb, EDGE_FALLTHRU);

return ret;
959}

961/* Join all the blocks in the flowgraph.  */

963static void
964make_edges (void)
965{
basic_block bb;
struct omp_region *cur_region = NULLnullptr;
auto_vec<basic_block> ab_edge_goto;
auto_vec<basic_block> ab_edge_call;
int cur_omp_region_idx = 0;

/* Create an edge from entry to the first block with executable
   statements in it.  */
make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr),
    BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS)((*(((cfun + 0))->cfg->x_basic_block_info))[((2))]),
    EDGE_FALLTHRU);

/* Traverse the basic block array placing edges.  */
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)
8
←
Assuming 'bb' is equal to field 'x_exit_block_ptr'→
  {
    int mer;

    if (!bb_to_omp_idx.is_empty ())
bb_to_omp_idx[bb->index] = cur_omp_region_idx;

    mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
    if (mer == 1)
ab_edge_goto.safe_push (bb);
    else if (mer == 2)
ab_edge_call.safe_push (bb);

    if (cur_region && bb_to_omp_idx.is_empty ())
bb_to_omp_idx.safe_grow_cleared (n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks), true);
  }

/* Computed gotos are hell to deal with, especially if there are
   lots of them with a large number of destinations.  So we factor
   them to a common computed goto location before we build the
   edge list.  After we convert back to normal form, we will un-factor
   the computed gotos since factoring introduces an unwanted jump.
   For non-local gotos and abnormal edges from calls to calls that return
   twice or forced labels, factor the abnormal edges too, by having all
   abnormal edges from the calls go to a common artificial basic block
   with ABNORMAL_DISPATCHER internal call and abnormal edges from that
   basic block to all forced labels and calls returning twice.
   We do this per-OpenMP structured block, because those regions
   are guaranteed to be single entry single exit by the standard,
   so it is not allowed to enter or exit such regions abnormally this way,
   thus all computed gotos, non-local gotos and setjmp/longjmp calls
   must not transfer control across SESE region boundaries.  */
if (!ab_edge_goto.is_empty () || !ab_edge_call.is_empty ())
9
←
Assuming the condition is true→
  {
    gimple_stmt_iterator gsi;
    basic_block dispatcher_bb_array[2] = { NULLnullptr, NULLnullptr };
    basic_block *dispatcher_bbs = dispatcher_bb_array;
    int count = n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks);

    if (!bb_to_omp_idx.is_empty ())
10
←
Assuming the condition is false→
11
←
Taking false branch→
dispatcher_bbs = XCNEWVEC (basic_block, 2 * count)((basic_block *) xcalloc ((2 * count), sizeof (basic_block)));

    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)
12
←
Assuming 'bb' is equal to field 'x_exit_block_ptr'→
13
←
Loop condition is false. Execution continues on line 1061→
{
 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
   {
     glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
     tree target;

     if (!label_stmt)
break;

     target = gimple_label_label (label_stmt);

     /* Make an edge to every label block that has been marked as a
 potential target for a computed goto or a non-local goto.  */
     if (FORCED_LABEL (target)((tree_check ((target), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1035, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
))
handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_goto,
		       true);
     if (DECL_NONLOCAL (target)((contains_struct_check ((target), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1038, __FUNCTION__))->decl_common.nonlocal_flag))
{
  handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
			 false);
  break;
}
   }

 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
   gsi_next_nondebug (&gsi);
 if (!gsi_end_p (gsi))
   {
     /* Make an edge to every setjmp-like call.  */
     gimple *call_stmt = gsi_stmt (gsi);
     if (is_gimple_call (call_stmt)
  && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE(1 << 7))
      || gimple_call_builtin_p (call_stmt,
				BUILT_IN_SETJMP_RECEIVER)))
handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
		       false);
   }
}

    if (!bb_to_omp_idx.is_empty ())
14
←
Assuming the condition is true→
15
←
Taking true branch→
XDELETE (dispatcher_bbs)free ((void*) (dispatcher_bbs));
16
←
Argument to free() is the address of the local variable 'dispatcher_bb_array', which is not memory allocated by malloc()
  }

omp_free_regions ();
1066}

1068/* Add SEQ after GSI.  Start new bb after GSI, and created further bbs as
 needed.  Returns true if new bbs were created.
 Note: This is transitional code, and should not be used for new code.  We
 should be able to get rid of this by rewriting all target va-arg
 gimplification hooks to use an interface gimple_build_cond_value as described
 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html.  */

1075bool
1076gimple_find_sub_bbs (gimple_seq seq, gimple_stmt_iterator *gsi)
1077{
gimple *stmt = gsi_stmt (*gsi);
basic_block bb = gimple_bb (stmt);
basic_block lastbb, afterbb;
int old_num_bbs = n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks);
edge e;
lastbb = make_blocks_1 (seq, bb);
if (old_num_bbs == n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks))
  return false;
e = split_block (bb, stmt);
/* Move e->dest to come after the new basic blocks.  */
afterbb = e->dest;
unlink_block (afterbb);
link_block (afterbb, lastbb);
redirect_edge_succ (e, bb->next_bb);
bb = bb->next_bb;
while (bb != afterbb)
  {
    struct omp_region *cur_region = NULLnullptr;
    profile_count cnt = profile_count::zero ();
    bool all = true;

    int cur_omp_region_idx = 0;
    int mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
    gcc_assert (!mer && !cur_region)((void)(!(!mer && !cur_region) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1101, __FUNCTION__), 0 : 0));
    add_bb_to_loop (bb, afterbb->loop_father);

    edge e;
    edge_iterator ei;
    FOR_EACH_EDGE (e, ei, bb->preds)for ((ei) = ei_start_1 (&((bb->preds))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
{
 if (e->count ().initialized_p ())
   cnt += e->count ();
 else
   all = false;
}
    tree_guess_outgoing_edge_probabilities (bb);
    if (all || profile_status_for_fn (cfun)(((cfun + 0))->cfg->x_profile_status) == PROFILE_READ)
      bb->count = cnt;

    bb = bb->next_bb;
  }
return true;
1120}

1122/* Find the next available discriminator value for LOCUS.  The
 discriminator distinguishes among several basic blocks that
 share a common locus, allowing for more accurate sample-based
 profiling.  */

1127static int
1128next_discriminator_for_locus (int line)
1129{
struct locus_discrim_map item;
struct locus_discrim_map **slot;

item.location_line = line;
item.discriminator = 0;
slot = discriminator_per_locus->find_slot_with_hash (&item, line, INSERT);
gcc_assert (slot)((void)(!(slot) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1136, __FUNCTION__), 0 : 0));
if (*slot == HTAB_EMPTY_ENTRY((void *) 0))
  {
    *slot = XNEW (struct locus_discrim_map)((struct locus_discrim_map *) xmalloc (sizeof (struct locus_discrim_map
)));
    gcc_assert (*slot)((void)(!(*slot) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1140, __FUNCTION__), 0 : 0));
    (*slot)->location_line = line;
    (*slot)->discriminator = 0;
  }
(*slot)->discriminator++;
return (*slot)->discriminator;
1146}

1148/* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line.  */

1150static bool
1151same_line_p (location_t locus1, expanded_location *from, location_t locus2)
1152{
expanded_location to;

if (locus1 == locus2)
  return true;

to = expand_location (locus2);

if (from->line != to.line)
  return false;
if (from->file == to.file)
  return true;
return (from->file != NULLnullptr
        && to.file != NULLnullptr
        && filename_cmp (from->file, to.file) == 0);
1167}

1169/* Assign a unique discriminator value to all statements in block bb that
 have the same line number as locus. */

1172static void
1173assign_discriminator (location_t locus, basic_block bb)
1174{
gimple_stmt_iterator gsi;
int discriminator;

if (locus == UNKNOWN_LOCATION((location_t) 0))
  return;

expanded_location locus_e = expand_location (locus);

discriminator = next_discriminator_for_locus (locus_e.line);

for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
  {
    gimple *stmt = gsi_stmt (gsi);
    location_t stmt_locus = gimple_location (stmt);
    if (same_line_p (locus, &locus_e, stmt_locus))
gimple_set_location (stmt,
   location_with_discriminator (stmt_locus, discriminator));
  }
1193}

1195/* Assign discriminators to statement locations.  */

1197static void
1198assign_discriminators (void)
1199{
basic_block bb;

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)
  {
    edge e;
    edge_iterator ei;
    gimple_stmt_iterator gsi;
    location_t curr_locus = UNKNOWN_LOCATION((location_t) 0);
    expanded_location curr_locus_e = {};
    int curr_discr = 0;

    /* Traverse the basic block, if two function calls within a basic block
are mapped to the same line, assign a new discriminator because a call
stmt could be a split point of a basic block.  */
    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
 gimple *stmt = gsi_stmt (gsi);

 if (curr_locus == UNKNOWN_LOCATION((location_t) 0))
   {
     curr_locus = gimple_location (stmt);
     curr_locus_e = expand_location (curr_locus);
   }
 else if (!same_line_p (curr_locus, &curr_locus_e, gimple_location (stmt)))
   {
     curr_locus = gimple_location (stmt);
     curr_locus_e = expand_location (curr_locus);
     curr_discr = 0;
   }
 else if (curr_discr != 0)
   {
     location_t loc = gimple_location (stmt);
     location_t dloc = location_with_discriminator (loc, curr_discr);
     gimple_set_location (stmt, dloc);
   }
 /* Allocate a new discriminator for CALL stmt.  */
 if (gimple_code (stmt) == GIMPLE_CALL)
   curr_discr = next_discriminator_for_locus (curr_locus);
}

    gimple *last = last_stmt (bb);
    location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION((location_t) 0);
    if (locus == UNKNOWN_LOCATION((location_t) 0))
continue;

    expanded_location locus_e = expand_location (locus);

    FOR_EACH_EDGE (e, ei, bb->succs)for ((ei) = ei_start_1 (&((bb->succs))); ei_cond ((ei)
, &(e)); ei_next (&(ei)))
{
 gimple *first = first_non_label_stmt (e->dest);
 gimple *last = last_stmt (e->dest);

 gimple *stmt_on_same_line = NULLnullptr;
 if (first && same_line_p (locus, &locus_e,
		     gimple_location (first)))
   stmt_on_same_line = first;
 else if (last && same_line_p (locus, &locus_e,
			gimple_location (last)))
   stmt_on_same_line = last;

 if (stmt_on_same_line)
   {
     if (has_discriminator (gimple_location (stmt_on_same_line))
  && !has_discriminator (locus))
assign_discriminator (locus, bb);
     else
assign_discriminator (locus, e->dest);
   }
}
  }
1270}

1272/* Create the edges for a GIMPLE_COND starting at block BB.  */

1274static void
1275make_cond_expr_edges (basic_block bb)
1276{
gcond *entry = as_a <gcond *> (last_stmt (bb));
gimple *then_stmt, *else_stmt;
basic_block then_bb, else_bb;
tree then_label, else_label;
edge e;

gcc_assert (entry)((void)(!(entry) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1283, __FUNCTION__), 0 : 0));
gcc_assert (gimple_code (entry) == GIMPLE_COND)((void)(!(gimple_code (entry) == GIMPLE_COND) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1284, __FUNCTION__), 0 : 0));

/* Entry basic blocks for each component.  */
then_label = gimple_cond_true_label (entry);
else_label = gimple_cond_false_label (entry);
then_bb = label_to_block (cfun(cfun + 0), then_label);
else_bb = label_to_block (cfun(cfun + 0), else_label);
then_stmt = first_stmt (then_bb);
else_stmt = first_stmt (else_bb);

e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
e->goto_locus = gimple_location (then_stmt);
e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
if (e)
  e->goto_locus = gimple_location (else_stmt);

/* We do not need the labels anymore.  */
gimple_cond_set_true_label (entry, NULL_TREE(tree) nullptr);
gimple_cond_set_false_label (entry, NULL_TREE(tree) nullptr);
1303}


1306/* Called for each element in the hash table (P) as we delete the
 edge to cases hash table.

 Clear all the CASE_CHAINs to prevent problems with copying of
 SWITCH_EXPRs and structure sharing rules, then free the hash table
 element.  */

1313bool
1314edge_to_cases_cleanup (edge const &, tree const &value, void *)
1315{
tree t, next;

for (t = value; t; t = next)
  {
    next = CASE_CHAIN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1320, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1320, __FUNCTION__)))));
    CASE_CHAIN (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1321, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1321, __FUNCTION__))))) = NULLnullptr;
  }

return true;
1325}

1327/* Start recording information mapping edges to case labels.  */

1329void
1330start_recording_case_labels (void)
1331{
gcc_assert (edge_to_cases == NULL)((void)(!(edge_to_cases == nullptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1332, __FUNCTION__), 0 : 0));
edge_to_cases = new hash_map<edge, tree>;
touched_switch_bbs = BITMAP_ALLOCbitmap_alloc (NULLnullptr);
1335}

1337/* Return nonzero if we are recording information for case labels.  */

1339static bool
1340recording_case_labels_p (void)
1341{
return (edge_to_cases != NULLnullptr);
1343}

1345/* Stop recording information mapping edges to case labels and
 remove any information we have recorded.  */
1347void
1348end_recording_case_labels (void)
1349{
bitmap_iterator bi;
unsigned i;
edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULLnullptr);
delete edge_to_cases;
edge_to_cases = NULLnullptr;
EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)for (bmp_iter_set_init (&(bi), (touched_switch_bbs), (0),
 &(i)); bmp_iter_set (&(bi), &(i)); bmp_iter_next
 (&(bi), &(i)))
  {
    basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i)((*(((cfun + 0))->cfg->x_basic_block_info))[(i)]);
    if (bb)
{
 gimple *stmt = last_stmt (bb);
 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
   group_case_labels_stmt (as_a <gswitch *> (stmt));
}
  }
BITMAP_FREE (touched_switch_bbs)((void) (bitmap_obstack_free ((bitmap) touched_switch_bbs), (
touched_switch_bbs) = (bitmap) nullptr));
1366}

1368/* If we are inside a {start,end}_recording_cases block, then return
 a chain of CASE_LABEL_EXPRs from T which reference E.

 Otherwise return NULL.  */

1373tree
1374get_cases_for_edge (edge e, gswitch *t)
1375{
tree *slot;
size_t i, n;

/* If we are not recording cases, then we do not have CASE_LABEL_EXPR
   chains available.  Return NULL so the caller can detect this case.  */
if (!recording_case_labels_p ())
  return NULLnullptr;

slot = edge_to_cases->get (e);
if (slot)
  return *slot;

/* If we did not find E in the hash table, then this must be the first
   time we have been queried for information about E & T.  Add all the
   elements from T to the hash table then perform the query again.  */

n = gimple_switch_num_labels (t);
for (i = 0; i < n; i++)
  {
    tree elt = gimple_switch_label (t, i);
    tree lab = CASE_LABEL (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1396, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1396, __FUNCTION__)))));
    basic_block label_bb = label_to_block (cfun(cfun + 0), lab);
    edge this_edge = find_edge (e->src, label_bb);

    /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
a new chain.  */
    tree &s = edge_to_cases->get_or_insert (this_edge);
    CASE_CHAIN (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1403, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1403, __FUNCTION__))))) = s;
    s = elt;
  }

return *edge_to_cases->get (e);
1408}

1410/* Create the edges for a GIMPLE_SWITCH starting at block BB.  */

1412static void
1413make_gimple_switch_edges (gswitch *entry, basic_block bb)
1414{
size_t i, n;

n = gimple_switch_num_labels (entry);

for (i = 0; i < n; ++i)
  {
    basic_block label_bb = gimple_switch_label_bb (cfun(cfun + 0), entry, i);
    make_edge (bb, label_bb, 0);
  }
1424}


1427/* Return the basic block holding label DEST.  */

1429basic_block
1430label_to_block (struct function *ifun, tree dest)
1431{
int uid = LABEL_DECL_UID (dest)((tree_check ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1432, __FUNCTION__, (LABEL_DECL)))->label_decl.label_decl_uid
);

/* We would die hard when faced by an undefined label.  Emit a label to
   the very first basic block.  This will hopefully make even the dataflow
   and undefined variable warnings quite right.  */
if (seen_error () && uid < 0)
  {
    gimple_stmt_iterator gsi =
gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS)((*(((cfun + 0))->cfg->x_basic_block_info))[((2))]));
    gimple *stmt;

    stmt = gimple_build_label (dest);
    gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
    uid = LABEL_DECL_UID (dest)((tree_check ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1445, __FUNCTION__, (LABEL_DECL)))->label_decl.label_decl_uid
);
  }
if (vec_safe_length (ifun->cfg->x_label_to_block_map) <= (unsigned int) uid)
  return NULLnullptr;
return (*ifun->cfg->x_label_to_block_map)[uid];
1450}

1452/* Create edges for a goto statement at block BB.  Returns true
 if abnormal edges should be created.  */

1455static bool
1456make_goto_expr_edges (basic_block bb)
1457{
gimple_stmt_iterator last = gsi_last_bb (bb);
gimple *goto_t = gsi_stmt (last);

/* A simple GOTO creates normal edges.  */
if (simple_goto_p (goto_t))
  {
    tree dest = gimple_goto_dest (goto_t);
    basic_block label_bb = label_to_block (cfun(cfun + 0), dest);
    edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
    e->goto_locus = gimple_location (goto_t);
    gsi_remove (&last, true);
    return false;
  }

/* A computed GOTO creates abnormal edges.  */
return true;
1474}

1476/* Create edges for an asm statement with labels at block BB.  */

1478static void
1479make_gimple_asm_edges (basic_block bb)
1480{
gasm *stmt = as_a <gasm *> (last_stmt (bb));
int i, n = gimple_asm_nlabels (stmt);

for (i = 0; i < n; ++i)
  {
    tree label = TREE_VALUE (gimple_asm_label_op (stmt, i))((tree_check ((gimple_asm_label_op (stmt, i)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1486, __FUNCTION__, (TREE_LIST)))->list.value);
    basic_block label_bb = label_to_block (cfun(cfun + 0), label);
    make_edge (bb, label_bb, 0);
  }
1490}

1492/*---------------------------------------------------------------------------
	       Flowgraph analysis
1494---------------------------------------------------------------------------*/

1496/* Cleanup useless labels in basic blocks.  This is something we wish
 to do early because it allows us to group case labels before creating
 the edges for the CFG, and it speeds up block statement iterators in
 all passes later on.
 We rerun this pass after CFG is created, to get rid of the labels that
 are no longer referenced.  After then we do not run it any more, since
 (almost) no new labels should be created.  */

1504/* A map from basic block index to the leading label of that block.  */
1505struct label_record
1506{
/* The label.  */
tree label;

/* True if the label is referenced from somewhere.  */
bool used;
1512};

1514/* Given LABEL return the first label in the same basic block.  */

1516static tree
1517main_block_label (tree label, label_record *label_for_bb)
1518{
basic_block bb = label_to_block (cfun(cfun + 0), label);
tree main_label = label_for_bb[bb->index].label;

/* label_to_block possibly inserted undefined label into the chain.  */
if (!main_label)
  {
    label_for_bb[bb->index].label = label;
    main_label = label;
  }

label_for_bb[bb->index].used = true;
return main_label;
1531}

1533/* Clean up redundant labels within the exception tree.  */

1535static void
1536cleanup_dead_labels_eh (label_record *label_for_bb)
1537{
eh_landing_pad lp;
eh_region r;
tree lab;
int i;

if (cfun(cfun + 0)->eh == NULLnullptr)
  return;

for (i = 1; vec_safe_iterate (cfun(cfun + 0)->eh->lp_array, i, &lp); ++i)
  if (lp && lp->post_landing_pad)
    {
lab = main_block_label (lp->post_landing_pad, label_for_bb);
if (lab != lp->post_landing_pad)
 {
   EH_LANDING_PAD_NR (lp->post_landing_pad)((tree_check ((lp->post_landing_pad), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1552, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
) = 0;
   lp->post_landing_pad = lab;
   EH_LANDING_PAD_NR (lab)((tree_check ((lab), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1554, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
) = lp->index;
 }
    }

FOR_ALL_EH_REGION (r)for ((r) = ((cfun + 0))->eh->region_tree; (r) != nullptr
; (r) = ehr_next (r, nullptr))
  switch (r->type)
    {
    case ERT_CLEANUP:
    case ERT_MUST_NOT_THROW:
break;

    case ERT_TRY:
{
 eh_catch c;
 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
   {
     lab = c->label;
     if (lab)
c->label = main_block_label (lab, label_for_bb);
   }
}
break;

    case ERT_ALLOWED_EXCEPTIONS:
lab = r->u.allowed.label;
if (lab)
 r->u.allowed.label = main_block_label (lab, label_for_bb);
break;
    }
1583}


1586/* Cleanup redundant labels.  This is a three-step process:
   1) Find the leading label for each block.
   2) Redirect all references to labels to the leading labels.
   3) Cleanup all useless labels.  */

1591void
1592cleanup_dead_labels (void)
1593{
basic_block bb;
label_record *label_for_bb = XCNEWVEC (struct label_record,((struct label_record *) xcalloc (((((cfun + 0))->cfg->
x_last_basic_block)), sizeof (struct label_record)))
			 last_basic_block_for_fn (cfun))((struct label_record *) xcalloc (((((cfun + 0))->cfg->
x_last_basic_block)), sizeof (struct label_record)));

/* Find a suitable label for each block.  We use the first user-defined
   label if there is one, or otherwise just the first label we see.  */
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)
  {
    gimple_stmt_iterator i;

    for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
{
 tree label;
 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));

 if (!label_stmt)
   break;

 label = gimple_label_label (label_stmt);

 /* If we have not yet seen a label for the current block,
    remember this one and see if there are more labels.  */
 if (!label_for_bb[bb->index].label)
   {
     label_for_bb[bb->index].label = label;
     continue;
   }

 /* If we did see a label for the current block already, but it
    is an artificially created label, replace it if the current
    label is a user defined label.  */
 if (!DECL_ARTIFICIAL (label)((contains_struct_check ((label), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1625, __FUNCTION__))->decl_common.artificial_flag)
     && DECL_ARTIFICIAL (label_for_bb[bb->index].label)((contains_struct_check ((label_for_bb[bb->index].label), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1626, __FUNCTION__))->decl_common.artificial_flag))
   {
     label_for_bb[bb->index].label = label;
     break;
   }
}
  }

/* Now redirect all jumps/branches to the selected label.
   First do so for each block ending in a control statement.  */
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)
  {
    gimple *stmt = last_stmt (bb);
    tree label, new_label;

    if (!stmt)
continue;

    switch (gimple_code (stmt))
{
case GIMPLE_COND:
 {
   gcond *cond_stmt = as_a <gcond *> (stmt);
   label = gimple_cond_true_label (cond_stmt);
   if (label)
     {
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  gimple_cond_set_true_label (cond_stmt, new_label);
     }

   label = gimple_cond_false_label (cond_stmt);
   if (label)
     {
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  gimple_cond_set_false_label (cond_stmt, new_label);
     }
 }
 break;

case GIMPLE_SWITCH:
 {
   gswitch *switch_stmt = as_a <gswitch *> (stmt);
   size_t i, n = gimple_switch_num_labels (switch_stmt);

   /* Replace all destination labels.  */
   for (i = 0; i < n; ++i)
     {
tree case_label = gimple_switch_label (switch_stmt, i);
label = CASE_LABEL (case_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((case_label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1676, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1676, __FUNCTION__)))));
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  CASE_LABEL (case_label)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((case_label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1679, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1679, __FUNCTION__))))) = new_label;
     }
   break;
 }

case GIMPLE_ASM:
 {
   gasm *asm_stmt = as_a <gasm *> (stmt);
   int i, n = gimple_asm_nlabels (asm_stmt);

   for (i = 0; i < n; ++i)
     {
tree cons = gimple_asm_label_op (asm_stmt, i);
tree label = main_block_label (TREE_VALUE (cons)((tree_check ((cons), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1692, __FUNCTION__, (TREE_LIST)))->list.value), label_for_bb);
TREE_VALUE (cons)((tree_check ((cons), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1693, __FUNCTION__, (TREE_LIST)))->list.value) = label;
     }
   break;
 }

/* We have to handle gotos until they're removed, and we don't
  remove them until after we've created the CFG edges.  */
case GIMPLE_GOTO:
 if (!computed_goto_p (stmt))
   {
     ggoto *goto_stmt = as_a <ggoto *> (stmt);
     label = gimple_goto_dest (goto_stmt);
     new_label = main_block_label (label, label_for_bb);
     if (new_label != label)
gimple_goto_set_dest (goto_stmt, new_label);
   }
 break;

case GIMPLE_TRANSACTION:
 {
   gtransaction *txn = as_a <gtransaction *> (stmt);

   label = gimple_transaction_label_norm (txn);
   if (label)
     {
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  gimple_transaction_set_label_norm (txn, new_label);
     }

   label = gimple_transaction_label_uninst (txn);
   if (label)
     {
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  gimple_transaction_set_label_uninst (txn, new_label);
     }

   label = gimple_transaction_label_over (txn);
   if (label)
     {
new_label = main_block_label (label, label_for_bb);
if (new_label != label)
  gimple_transaction_set_label_over (txn, new_label);
     }
 }
 break;

default:
 break;
    }
  }

/* Do the same for the exception region tree labels.  */
cleanup_dead_labels_eh (label_for_bb);

/* Finally, purge dead labels.  All user-defined labels and labels that
   can be the target of non-local gotos and labels which have their
   address taken are preserved.  */
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)
  {
    gimple_stmt_iterator i;
    tree label_for_this_bb = label_for_bb[bb->index].label;

    if (!label_for_this_bb)
continue;

    /* If the main label of the block is unused, we may still remove it.  */
    if (!label_for_bb[bb->index].used)
label_for_this_bb = NULLnullptr;

    for (i = gsi_start_bb (bb); !gsi_end_p (i); )
{
 tree label;
 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));

 if (!label_stmt)
   break;

 label = gimple_label_label (label_stmt);

 if (label == label_for_this_bb
     || !DECL_ARTIFICIAL (label)((contains_struct_check ((label), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1775, __FUNCTION__))->decl_common.artificial_flag)
     || DECL_NONLOCAL (label)((contains_struct_check ((label), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1776, __FUNCTION__))->decl_common.nonlocal_flag)
     || FORCED_LABEL (label)((tree_check ((label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1777, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
))
   gsi_next (&i);
 else
   {
     gcc_checking_assert (EH_LANDING_PAD_NR (label) == 0)((void)(!(((tree_check ((label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1781, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
) == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1781, __FUNCTION__), 0 : 0));
     gsi_remove (&i, true);
   }
}
  }

free (label_for_bb);
1788}

1790/* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
 the ones jumping to the same label.
 Eg. three separate entries 1: 2: 3: become one entry 1..3:  */

1794bool
1795group_case_labels_stmt (gswitch *stmt)
1796{
int old_size = gimple_switch_num_labels (stmt);
int i, next_index, new_size;
basic_block default_bb = NULLnullptr;
hash_set<tree> *removed_labels = NULLnullptr;

default_bb = gimple_switch_default_bb (cfun(cfun + 0), stmt);

/* Look for possible opportunities to merge cases.  */
new_size = i = 1;
while (i < old_size)
  {
    tree base_case, base_high;
    basic_block base_bb;

    base_case = gimple_switch_label (stmt, i);

    gcc_assert (base_case)((void)(!(base_case) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1813, __FUNCTION__), 0 : 0));
    base_bb = label_to_block (cfun(cfun + 0), CASE_LABEL (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1814, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1814, __FUNCTION__))))));

    /* Discard cases that have the same destination as the default case or
whose destination blocks have already been removed as unreachable.  */
    if (base_bb == NULLnullptr
 || base_bb == default_bb
 || (removed_labels
     && removed_labels->contains (CASE_LABEL (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1821, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1821, __FUNCTION__))))))))
{
 i++;
 continue;
}

    base_high = CASE_HIGH (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1827, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1827, __FUNCTION__)))))
 ? CASE_HIGH (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1828, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1828, __FUNCTION__)))))
 : CASE_LOW (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1829, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1829, __FUNCTION__)))));
    next_index = i + 1;

    /* Try to merge case labels.  Break out when we reach the end
of the label vector or when we cannot merge the next case
label with the current one.  */
    while (next_index < old_size)
{
 tree merge_case = gimple_switch_label (stmt, next_index);
 basic_block merge_bb = label_to_block (cfun(cfun + 0), CASE_LABEL (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1838, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1838, __FUNCTION__))))));
 wide_int bhp1 = wi::to_wide (base_high) + 1;

 /* Merge the cases if they jump to the same place,
    and their ranges are consecutive.  */
 if (merge_bb == base_bb
     && (removed_labels == NULLnullptr
  || !removed_labels->contains (CASE_LABEL (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1845, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1845, __FUNCTION__)))))))
     && wi::to_wide (CASE_LOW (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1846, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1846, __FUNCTION__)))))) == bhp1)
   {
     base_high
= (CASE_HIGH (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1849, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1849, __FUNCTION__)))))
   ? CASE_HIGH (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1850, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1850, __FUNCTION__))))) : CASE_LOW (merge_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((merge_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1850, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1850, __FUNCTION__))))));
     CASE_HIGH (base_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((base_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1851, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1851, __FUNCTION__))))) = base_high;
     next_index++;
   }
 else
   break;
}

    /* Discard cases that have an unreachable destination block.  */
    if (EDGE_COUNT (base_bb->succs)vec_safe_length (base_bb->succs) == 0
 && gimple_seq_unreachable_p (bb_seq (base_bb))
 /* Don't optimize this if __builtin_unreachable () is the
    implicitly added one by the C++ FE too early, before
    -Wreturn-type can be diagnosed.  We'll optimize it later
    during switchconv pass or any other cfg cleanup.  */
 && (gimple_in_ssa_p (cfun(cfun + 0))
     || (LOCATION_LOCUS (gimple_location (last_stmt (base_bb)))((IS_ADHOC_LOC (gimple_location (last_stmt (base_bb)))) ? get_location_from_adhoc_loc
 (line_table, gimple_location (last_stmt (base_bb))) : (gimple_location
 (last_stmt (base_bb))))
  != BUILTINS_LOCATION((location_t) 1))))
{
 edge base_edge = find_edge (gimple_bb (stmt), base_bb);
 if (base_edge != NULLnullptr)
   {
     for (gimple_stmt_iterator gsi = gsi_start_bb (base_bb);
   !gsi_end_p (gsi); gsi_next (&gsi))
if (glabel *stmt = dyn_cast <glabel *> (gsi_stmt (gsi)))
  {
    if (FORCED_LABEL (gimple_label_label (stmt))((tree_check ((gimple_label_label (stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1876, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
	|| DECL_NONLOCAL (gimple_label_label (stmt))((contains_struct_check ((gimple_label_label (stmt)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1877, __FUNCTION__))->decl_common.nonlocal_flag))
      {
	/* Forced/non-local labels aren't going to be removed,
	   but they will be moved to some neighbouring basic
	   block. If some later case label refers to one of
	   those labels, we should throw that case away rather
	   than keeping it around and refering to some random
	   other basic block without an edge to it.  */
	if (removed_labels == NULLnullptr)
	  removed_labels = new hash_set<tree>;
	removed_labels->add (gimple_label_label (stmt));
      }
  }
else
  break;
     remove_edge_and_dominated_blocks (base_edge);
   }
 i = next_index;
 continue;
}

    if (new_size < i)
gimple_switch_set_label (stmt, new_size,
		 gimple_switch_label (stmt, i));
    i = next_index;
    new_size++;
  }

gcc_assert (new_size <= old_size)((void)(!(new_size <= old_size) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1905, __FUNCTION__), 0 : 0));

if (new_size < old_size)
  gimple_switch_set_num_labels (stmt, new_size);

delete removed_labels;
return new_size < old_size;
1912}

1914/* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
 and scan the sorted vector of cases.  Combine the ones jumping to the
 same label.  */

1918bool
1919group_case_labels (void)
1920{
basic_block bb;
bool changed = false;

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)
  {
    gimple *stmt = last_stmt (bb);
    if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
changed |= group_case_labels_stmt (as_a <gswitch *> (stmt));
  }

return changed;
1932}

1934/* Checks whether we can merge block B into block A.  */

1936static bool
1937gimple_can_merge_blocks_p (basic_block a, basic_block b)
1938{
gimple *stmt;

if (!single_succ_p (a))
  return false;

if (single_succ_edge (a)->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
))
  return false;

if (single_succ (a) != b)
  return false;

if (!single_pred_p (b))
  return false;

if (a == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr)
    || b == EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr))
  return false;

/* If A ends by a statement causing exceptions or something similar, we
   cannot merge the blocks.  */
stmt = last_stmt (a);
if (stmt && stmt_ends_bb_p (stmt))
  return false;

/* Do not allow a block with only a non-local label to be merged.  */
if (stmt)
  if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
    if (DECL_NONLOCAL (gimple_label_label (label_stmt))((contains_struct_check ((gimple_label_label (label_stmt)), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1966, __FUNCTION__))->decl_common.nonlocal_flag))
return false;

/* Examine the labels at the beginning of B.  */
for (gimple_stmt_iterator gsi = gsi_start_bb (b); !gsi_end_p (gsi);
     gsi_next (&gsi))
  {
    tree lab;
    glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
    if (!label_stmt)
break;
    lab = gimple_label_label (label_stmt);

    /* Do not remove user forced labels or for -O0 any user labels.  */
    if (!DECL_ARTIFICIAL (lab)((contains_struct_check ((lab), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1980, __FUNCTION__))->decl_common.artificial_flag) && (!optimizeglobal_options.x_optimize || FORCED_LABEL (lab)((tree_check ((lab), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 1980, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)))
return false;
  }

/* Protect simple loop latches.  We only want to avoid merging
   the latch with the loop header or with a block in another
   loop in this case.  */
if (current_loops((cfun + 0)->x_current_loops)
    && b->loop_father->latch == b
    && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES)
    && (b->loop_father->header == a
 || b->loop_father != a->loop_father))
  return false;

/* It must be possible to eliminate all phi nodes in B.  If ssa form
   is not up-to-date and a name-mapping is registered, we cannot eliminate
   any phis.  Symbols marked for renaming are never a problem though.  */
for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);
     gsi_next (&gsi))
  {
    gphi *phi = gsi.phi ();
    /* Technically only new names matter.  */
    if (name_registered_for_update_p (PHI_RESULT (phi)get_def_from_ptr (gimple_phi_result_ptr (phi))))
return false;
  }

/* When not optimizing, don't merge if we'd lose goto_locus.  */
if (!optimizeglobal_options.x_optimize
    && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION((location_t) 0))
  {
    location_t goto_locus = single_succ_edge (a)->goto_locus;
    gimple_stmt_iterator prev, next;
    prev = gsi_last_nondebug_bb (a);
    next = gsi_after_labels (b);
    if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
gsi_next_nondebug (&next);
    if ((gsi_end_p (prev)
  || gimple_location (gsi_stmt (prev)) != goto_locus)
 && (gsi_end_p (next)
     || gimple_location (gsi_stmt (next)) != goto_locus))
return false;
  }

return true;
2024}

2026/* Replaces all uses of NAME by VAL.  */

2028void
2029replace_uses_by (tree name, tree val)
2030{
imm_use_iterator imm_iter;
use_operand_p use;
gimple *stmt;
edge e;

FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(imm_iter), (name))), &
(imm_iter))); !end_imm_use_stmt_p (&(imm_iter)); (void) (
(stmt) = next_imm_use_stmt (&(imm_iter))))
  {
    /* Mark the block if we change the last stmt in it.  */
    if (cfgcleanup_altered_bbs
 && stmt_ends_bb_p (stmt))
bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);

    FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)for ((use) = first_imm_use_on_stmt (&(imm_iter)); !end_imm_use_on_stmt_p
 (&(imm_iter)); (void) ((use) = next_imm_use_on_stmt (&
(imm_iter))))
      {
 replace_exp (use, val);

 if (gimple_code (stmt) == GIMPLE_PHI)
   {
     e = gimple_phi_arg_edge (as_a <gphi *> (stmt),
		       PHI_ARG_INDEX_FROM_USE (use)phi_arg_index_from_use (use));
     if (e->flags & EDGE_ABNORMAL
  && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)(tree_check ((val), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2052, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag)
{
  /* This can only occur for virtual operands, since
     for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
     would prevent replacement.  */
  gcc_checking_assert (virtual_operand_p (name))((void)(!(virtual_operand_p (name)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2057, __FUNCTION__), 0 : 0));
  SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val)(tree_check ((val), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2058, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag = 1;
}
   }
}

    if (gimple_code (stmt) != GIMPLE_PHI)
{
 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
 gimple *orig_stmt = stmt;
 size_t i;

 /* FIXME.  It shouldn't be required to keep TREE_CONSTANT
    on ADDR_EXPRs up-to-date on GIMPLE.  Propagation will
    only change sth from non-invariant to invariant, and only
    when propagating constants.  */
 if (is_gimple_min_invariant (val))
   for (i = 0; i < gimple_num_ops (stmt); i++)
     {
tree op = gimple_op (stmt, i);
/* Operands may be empty here.  For example, the labels
   of a GIMPLE_COND are nulled out following the creation
   of the corresponding CFG edges.  */
if (op && TREE_CODE (op)((enum tree_code) (op)->base.code) == ADDR_EXPR)
  recompute_tree_invariant_for_addr_expr (op);
     }

 if (fold_stmt (&gsi))
   stmt = gsi_stmt (gsi);

 if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
   gimple_purge_dead_eh_edges (gimple_bb (stmt));

 update_stmt (stmt);
}
  }

gcc_checking_assert (has_zero_uses (name))((void)(!(has_zero_uses (name)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2094, __FUNCTION__), 0 : 0));

/* Also update the trees stored in loop structures.  */
if (current_loops((cfun + 0)->x_current_loops))
  {
    for (auto loop : loops_list (cfun(cfun + 0), 0))
 substitute_in_loop_info (loop, name, val);
  }
2102}

2104/* Merge block B into block A.  */

2106static void
2107gimple_merge_blocks (basic_block a, basic_block b)
2108{
gimple_stmt_iterator last, gsi;
gphi_iterator psi;

if (dump_file)
  fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);

/* Remove all single-valued PHI nodes from block B of the form
   V_i = PHI <V_j> by propagating V_j to all the uses of V_i.  */
gsi = gsi_last_bb (a);
for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
  {
    gimple *phi = gsi_stmt (psi);
    tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
    gimple *copy;
    bool may_replace_uses = (virtual_operand_p (def)
	       || may_propagate_copy (def, use));

    /* In case we maintain loop closed ssa form, do not propagate arguments
of loop exit phi nodes.  */
    if (current_loops((cfun + 0)->x_current_loops)
 && loops_state_satisfies_p (LOOP_CLOSED_SSA)
 && !virtual_operand_p (def)
 && TREE_CODE (use)((enum tree_code) (use)->base.code) == SSA_NAME
 && a->loop_father != b->loop_father)
may_replace_uses = false;

    if (!may_replace_uses)
{
 gcc_assert (!virtual_operand_p (def))((void)(!(!virtual_operand_p (def)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2137, __FUNCTION__), 0 : 0));

 /* Note that just emitting the copies is fine -- there is no problem
    with ordering of phi nodes.  This is because A is the single
    predecessor of B, therefore results of the phi nodes cannot
    appear as arguments of the phi nodes.  */
 copy = gimple_build_assign (def, use);
 gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
        remove_phi_node (&psi, false);
}
    else
      {
 /* If we deal with a PHI for virtual operands, we can simply
    propagate these without fussing with folding or updating
    the stmt.  */
 if (virtual_operand_p (def))
   {
     imm_use_iterator iter;
     use_operand_p use_p;
     gimple *stmt;

     FOR_EACH_IMM_USE_STMT (stmt, iter, def)for (struct auto_end_imm_use_stmt_traverse auto_end_imm_use_stmt_traverse
 ((((stmt) = first_imm_use_stmt (&(iter), (def))), &(
iter))); !end_imm_use_stmt_p (&(iter)); (void) ((stmt) = next_imm_use_stmt
 (&(iter))))
FOR_EACH_IMM_USE_ON_STMT (use_p, iter)for ((use_p) = first_imm_use_on_stmt (&(iter)); !end_imm_use_on_stmt_p
 (&(iter)); (void) ((use_p) = next_imm_use_on_stmt (&
(iter))))
  SET_USE (use_p, use)set_ssa_use_from_ptr (use_p, use);

     if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def)(tree_check ((def), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2162, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag)
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use)(tree_check ((use), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2163, __FUNCTION__, (SSA_NAME)))->base.asm_written_flag = 1;
   }
 else
          replace_uses_by (def, use);

        remove_phi_node (&psi, true);
      }
  }

/* Ensure that B follows A.  */
move_block_after (b, a);

gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU)((void)(!(single_succ_edge (a)->flags & EDGE_FALLTHRU)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2175, __FUNCTION__), 0 : 0));
gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)))((void)(!(!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a))) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2176, __FUNCTION__), 0 : 0));

/* Remove labels from B and set gimple_bb to A for other statements.  */
for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
  {
    gimple *stmt = gsi_stmt (gsi);
    if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
{
 tree label = gimple_label_label (label_stmt);
 int lp_nr;

 gsi_remove (&gsi, false);

 /* Now that we can thread computed gotos, we might have
    a situation where we have a forced label in block B
    However, the label at the start of block B might still be
    used in other ways (think about the runtime checking for
    Fortran assigned gotos).  So we cannot just delete the
    label.  Instead we move the label to the start of block A.  */
 if (FORCED_LABEL (label)((tree_check ((label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2195, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
))
   {
     gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
     tree first_label = NULL_TREE(tree) nullptr;
     if (!gsi_end_p (dest_gsi))
if (glabel *first_label_stmt
    = dyn_cast <glabel *> (gsi_stmt (dest_gsi)))
  first_label = gimple_label_label (first_label_stmt);
     if (first_label
  && (DECL_NONLOCAL (first_label)((contains_struct_check ((first_label), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2204, __FUNCTION__))->decl_common.nonlocal_flag)
      || EH_LANDING_PAD_NR (first_label)((tree_check ((first_label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2205, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
) != 0))
gsi_insert_after (&dest_gsi, stmt, GSI_NEW_STMT);
     else
gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
   }
 /* Other user labels keep around in a form of a debug stmt.  */
 else if (!DECL_ARTIFICIAL (label)((contains_struct_check ((label), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2211, __FUNCTION__))->decl_common.artificial_flag) && MAY_HAVE_DEBUG_BIND_STMTSglobal_options.x_flag_var_tracking_assignments)
   {
     gimple *dbg = gimple_build_debug_bind (label,
				     integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
				     stmt);
     gimple_debug_bind_reset_value (dbg);
     gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
   }

 lp_nr = EH_LANDING_PAD_NR (label)((tree_check ((label), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2220, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
);
 if (lp_nr)
   {
     eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
     lp->post_landing_pad = NULLnullptr;
   }
}
    else
{
 gimple_set_bb (stmt, a);
 gsi_next (&gsi);
}
  }

/* When merging two BBs, if their counts are different, the larger count
   is selected as the new bb count. This is to handle inconsistent
   profiles.  */
if (a->loop_father == b->loop_father)
  {
    a->count = a->count.merge (b->count);
  }

/* Merge the sequences.  */
last = gsi_last_bb (a);
gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
set_bb_seq (b, NULLnullptr);

if (cfgcleanup_altered_bbs)
  bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
2249}


2252/* Return the one of two successors of BB that is not reachable by a
 complex edge, if there is one.  Else, return BB.  We use
 this in optimizations that use post-dominators for their heuristics,
 to catch the cases in C++ where function calls are involved.  */

2257basic_block
2258single_noncomplex_succ (basic_block bb)
2259{
edge e0, e1;
if (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) != 2)
  return bb;

e0 = EDGE_SUCC (bb, 0)(*(bb)->succs)[(0)];
e1 = EDGE_SUCC (bb, 1)(*(bb)->succs)[(1)];
if (e0->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
))
  return e1->dest;
if (e1->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
))
  return e0->dest;

return bb;
2272}

2274/* T is CALL_EXPR.  Set current_function_calls_* flags.  */

2276void
2277notice_special_calls (gcall *call)
2278{
int flags = gimple_call_flags (call);

if (flags & ECF_MAY_BE_ALLOCA(1 << 5))
  cfun(cfun + 0)->calls_alloca = true;
if (flags & ECF_RETURNS_TWICE(1 << 7))
  cfun(cfun + 0)->calls_setjmp = true;
2285}


2288/* Clear flags set by notice_special_calls.  Used by dead code removal
 to update the flags.  */

2291void
2292clear_special_calls (void)
2293{
cfun(cfun + 0)->calls_alloca = false;
cfun(cfun + 0)->calls_setjmp = false;
2296}

2298/* Remove PHI nodes associated with basic block BB and all edges out of BB.  */

2300static void
2301remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
2302{
/* Since this block is no longer reachable, we can just delete all
   of its PHI nodes.  */
remove_phi_nodes (bb);

/* Remove edges to BB's successors.  */
while (EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) > 0)
  remove_edge (EDGE_SUCC (bb, 0)(*(bb)->succs)[(0)]);
2310}


2313/* Remove statements of basic block BB.  */

2315static void
2316remove_bb (basic_block bb)
2317{
gimple_stmt_iterator i;

if (dump_file)
  {
    fprintf (dump_file, "Removing basic block %d\n", bb->index);
    if (dump_flags & TDF_DETAILS)
{
 dump_bb (dump_file, bb, 0, TDF_BLOCKS);
 fprintf (dump_file, "\n");
}
  }

if (current_loops((cfun + 0)->x_current_loops))
  {
    class loop *loop = bb->loop_father;

    /* If a loop gets removed, clean up the information associated
with it.  */
    if (loop->latch == bb
 || loop->header == bb)
free_numbers_of_iterations_estimates (loop);
  }

/* Remove all the instructions in the block.  */
if (bb_seq (bb) != NULLnullptr)
  {
    /* Walk backwards so as to get a chance to substitute all
released DEFs into debug stmts.  See
eliminate_unnecessary_stmts() in tree-ssa-dce.cc for more
details.  */
    for (i = gsi_last_bb (bb); !gsi_end_p (i);)
{
 gimple *stmt = gsi_stmt (i);
 glabel *label_stmt = dyn_cast <glabel *> (stmt);
 if (label_stmt
     && (FORCED_LABEL (gimple_label_label (label_stmt))((tree_check ((gimple_label_label (label_stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2353, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
  || DECL_NONLOCAL (gimple_label_label (label_stmt))((contains_struct_check ((gimple_label_label (label_stmt)), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2354, __FUNCTION__))->decl_common.nonlocal_flag)))
   {
     basic_block new_bb;
     gimple_stmt_iterator new_gsi;

     /* A non-reachable non-local label may still be referenced.
 But it no longer needs to carry the extra semantics of
 non-locality.  */
     if (DECL_NONLOCAL (gimple_label_label (label_stmt))((contains_struct_check ((gimple_label_label (label_stmt)), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2362, __FUNCTION__))->decl_common.nonlocal_flag))
{
  DECL_NONLOCAL (gimple_label_label (label_stmt))((contains_struct_check ((gimple_label_label (label_stmt)), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2364, __FUNCTION__))->decl_common.nonlocal_flag) = 0;
  FORCED_LABEL (gimple_label_label (label_stmt))((tree_check ((gimple_label_label (label_stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2365, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
) = 1;
}

     new_bb = bb->prev_bb;
     /* Don't move any labels into ENTRY block.  */
     if (new_bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr))
{
  new_bb = single_succ (new_bb);
  gcc_assert (new_bb != bb)((void)(!(new_bb != bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2373, __FUNCTION__), 0 : 0));
}
     if ((unsigned) bb->index < bb_to_omp_idx.length ()
  && ((unsigned) new_bb->index >= bb_to_omp_idx.length ()
      || (bb_to_omp_idx[bb->index]
	  != bb_to_omp_idx[new_bb->index])))
{
  /* During cfg pass make sure to put orphaned labels
     into the right OMP region.  */
  unsigned int i;
  int idx;
  new_bb = NULLnullptr;
  FOR_EACH_VEC_ELT (bb_to_omp_idx, i, idx)for (i = 0; (bb_to_omp_idx).iterate ((i), &(idx)); ++(i))
    if (i >= NUM_FIXED_BLOCKS(2)
	&& idx == bb_to_omp_idx[bb->index]
	&& i != (unsigned) bb->index)
      {
	new_bb = BASIC_BLOCK_FOR_FN (cfun, i)((*(((cfun + 0))->cfg->x_basic_block_info))[(i)]);
	break;
      }
  if (new_bb == NULLnullptr)
    {
      new_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_entry_block_ptr));
      gcc_assert (new_bb != bb)((void)(!(new_bb != bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2396, __FUNCTION__), 0 : 0));
    }
}
     new_gsi = gsi_after_labels (new_bb);
     gsi_remove (&i, false);
     gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
   }
 else
   {
     /* Release SSA definitions.  */
     release_defs (stmt);
     gsi_remove (&i, true);
   }

 if (gsi_end_p (i))
   i = gsi_last_bb (bb);
 else
   gsi_prev (&i);
}
  }

if ((unsigned) bb->index < bb_to_omp_idx.length ())
  bb_to_omp_idx[bb->index] = -1;
remove_phi_nodes_and_edges_for_unreachable_block (bb);
bb->il.gimple.seq = NULLnullptr;
bb->il.gimple.phi_nodes = NULLnullptr;
2422}


2425/* Given a basic block BB and a value VAL for use in the final statement
 of the block (if a GIMPLE_COND, GIMPLE_SWITCH, or computed goto), return
 the edge that will be taken out of the block.
 If VAL is NULL_TREE, then the current value of the final statement's
 predicate or index is used.
 If the value does not match a unique edge, NULL is returned.  */

2432edge
2433find_taken_edge (basic_block bb, tree val)
2434{
gimple *stmt;

stmt = last_stmt (bb);

/* Handle ENTRY and EXIT.  */
if (!stmt)
  return NULLnullptr;

if (gimple_code (stmt) == GIMPLE_COND)
  return find_taken_edge_cond_expr (as_a <gcond *> (stmt), val);

if (gimple_code (stmt) == GIMPLE_SWITCH)
  return find_taken_edge_switch_expr (as_a <gswitch *> (stmt), val);

if (computed_goto_p (stmt))
  {
    /* Only optimize if the argument is a label, if the argument is
not a label then we cannot construct a proper CFG.

       It may be the case that we only need to allow the LABEL_REF to
       appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
       appear inside a LABEL_EXPR just to be safe.  */
    if (val
 && (TREE_CODE (val)((enum tree_code) (val)->base.code) == ADDR_EXPR || TREE_CODE (val)((enum tree_code) (val)->base.code) == LABEL_EXPR)
 && TREE_CODE (TREE_OPERAND (val, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((val), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2459, __FUNCTION__))))))->base.code) == LABEL_DECL)
return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0)(*((const_cast<tree*> (tree_operand_check ((val), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2460, __FUNCTION__))))));
  }

/* Otherwise we only know the taken successor edge if it's unique.  */
return single_succ_p (bb) ? single_succ_edge (bb) : NULLnullptr;
2465}

2467/* Given a constant value VAL and the entry block BB to a GOTO_EXPR
 statement, determine which of the outgoing edges will be taken out of the
 block.  Return NULL if either edge may be taken.  */

2471static edge
2472find_taken_edge_computed_goto (basic_block bb, tree val)
2473{
basic_block dest;
edge e = NULLnullptr;

dest = label_to_block (cfun(cfun + 0), val);
if (dest)
  e = find_edge (bb, dest);

/* It's possible for find_edge to return NULL here on invalid code
   that abuses the labels-as-values extension (e.g. code that attempts to
   jump *between* functions via stored labels-as-values; PR 84136).
   If so, then we simply return that NULL for the edge.
   We don't currently have a way of detecting such invalid code, so we
   can't assert that it was the case when a NULL edge occurs here.  */

return e;
2489}

2491/* Given COND_STMT and a constant value VAL for use as the predicate,
 determine which of the two edges will be taken out of
 the statement's block.  Return NULL if either edge may be taken.
 If VAL is NULL_TREE, then the current value of COND_STMT's predicate
 is used.  */

2497static edge
2498find_taken_edge_cond_expr (const gcond *cond_stmt, tree val)
2499{
edge true_edge, false_edge;

if (val == NULL_TREE(tree) nullptr)
  {
    /* Use the current value of the predicate.  */
    if (gimple_cond_true_p (cond_stmt))
val = integer_one_nodeglobal_trees[TI_INTEGER_ONE];
    else if (gimple_cond_false_p (cond_stmt))
val = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
    else
return NULLnullptr;
  }
else if (TREE_CODE (val)((enum tree_code) (val)->base.code) != INTEGER_CST)
  return NULLnullptr;

extract_true_false_edges_from_block (gimple_bb (cond_stmt),
		       &true_edge, &false_edge);

return (integer_zerop (val) ? false_edge : true_edge);
2519}

2521/* Given SWITCH_STMT and an INTEGER_CST VAL for use as the index, determine
 which edge will be taken out of the statement's block.  Return NULL if any
 edge may be taken.
 If VAL is NULL_TREE, then the current value of SWITCH_STMT's index
 is used.  */

2527edge
2528find_taken_edge_switch_expr (const gswitch *switch_stmt, tree val)
2529{
basic_block dest_bb;
edge e;
tree taken_case;

if (gimple_switch_num_labels (switch_stmt) == 1)
  taken_case = gimple_switch_default_label (switch_stmt);
else
  {
    if (val == NULL_TREE(tree) nullptr)
val = gimple_switch_index (switch_stmt);
    if (TREE_CODE (val)((enum tree_code) (val)->base.code) != INTEGER_CST)
return NULLnullptr;
    else
taken_case = find_case_label_for_value (switch_stmt, val);
  }
dest_bb = label_to_block (cfun(cfun + 0), CASE_LABEL (taken_case)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((taken_case), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2545, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2545, __FUNCTION__))))));

e = find_edge (gimple_bb (switch_stmt), dest_bb);
gcc_assert (e)((void)(!(e) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2548, __FUNCTION__), 0 : 0));
return e;
2550}


2553/* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
 We can make optimal use here of the fact that the case labels are
 sorted: We can do a binary search for a case matching VAL.  */

2557tree
2558find_case_label_for_value (const gswitch *switch_stmt, tree val)
2559{
size_t low, high, n = gimple_switch_num_labels (switch_stmt);
tree default_case = gimple_switch_default_label (switch_stmt);

for (low = 0, high = n; high - low > 1; )
  {
    size_t i = (high + low) / 2;
    tree t = gimple_switch_label (switch_stmt, i);
    int cmp;

    /* Cache the result of comparing CASE_LOW and val.  */
    cmp = tree_int_cst_compare (CASE_LOW (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2570, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2570, __FUNCTION__))))), val);

    if (cmp > 0)
high = i;
    else
low = i;

    if (CASE_HIGH (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2577, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2577, __FUNCTION__))))) == NULLnullptr)
{
 /* A singe-valued case label.  */
 if (cmp == 0)
   return t;
}
    else
{
 /* A case range.  We can only handle integer ranges.  */
 if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2586, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2586, __FUNCTION__))))), val) >= 0)
   return t;
}
  }

return default_case;
2592}


2595/* Dump a basic block on stderr.  */

2597void
2598gimple_debug_bb (basic_block bb)
2599{
dump_bb (stderrstderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
2601}


2604/* Dump basic block with index N on stderr.  */

2606basic_block
2607gimple_debug_bb_n (int n)
2608{
gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n)((*(((cfun + 0))->cfg->x_basic_block_info))[(n)]));
return BASIC_BLOCK_FOR_FN (cfun, n)((*(((cfun + 0))->cfg->x_basic_block_info))[(n)]);
2611}


2614/* Dump the CFG on stderr.

 FLAGS are the same used by the tree dumping functions
 (see TDF_* in dumpfile.h).  */

2619void
2620gimple_debug_cfg (dump_flags_t flags)
2621{
gimple_dump_cfg (stderrstderr, flags);
2623}


2626/* Dump the program showing basic block boundaries on the given FILE.

 FLAGS are the same used by the tree dumping functions (see TDF_* in
 tree.h).  */

2631void
2632gimple_dump_cfg (FILE *file, dump_flags_t flags)
2633{
if (flags & TDF_DETAILS)
  {
    dump_function_header (file, current_function_decl, flags);
    fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
      n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks), n_edges_for_fn (cfun)(((cfun + 0))->cfg->x_n_edges),
      last_basic_block_for_fn (cfun)(((cfun + 0))->cfg->x_last_basic_block));

    brief_dump_cfg (file, flags);
    fprintf (file, "\n");
  }

if (flags & TDF_STATS)
  dump_cfg_stats (file);

dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
2649}


2652/* Dump CFG statistics on FILE.  */

2654void
2655dump_cfg_stats (FILE *file)
2656{
static long max_num_merged_labels = 0;
unsigned long size, total = 0;
long num_edges;
basic_block bb;
const char * const fmt_str   = "%-30s%-13s%12s\n";
const char * const fmt_str_1 = "%-30s%13d" PRsa (11)"%" "11" "l" "u" "%c" "\n";
const char * const fmt_str_2 = "%-30s%13ld" PRsa (11)"%" "11" "l" "u" "%c" "\n";
const char * const fmt_str_3 = "%-43s" PRsa (11)"%" "11" "l" "u" "%c" "\n";
const char *funcname = current_function_name ();

fprintf (file, "\nCFG Statistics for %s\n\n", funcname);

fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str, "", "  Number of  ", "Memory");
fprintf (file, fmt_str, "", "  instances  ", "used ");
fprintf (file, "---------------------------------------------------------\n");

size = n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks) * sizeof (struct basic_block_def);
total += size;
fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun)(((cfun + 0))->cfg->x_n_basic_blocks),
  SIZE_AMOUNT (size)(uint64_t)(((size) < 10 * 1024 ? (size) : ((size) < 10 *
 (1024 * 1024) ? (size) / 1024 : (size) / (1024 * 1024)))), (
(size) < 10 * 1024 ? ' ' : ((size) < 10 * (1024 * 1024)
 ? 'k' : 'M')));

num_edges = 0;
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)
  num_edges += EDGE_COUNT (bb->succs)vec_safe_length (bb->succs);
size = num_edges * sizeof (class edge_def);
total += size;
fprintf (file, fmt_str_2, "Edges", num_edges, SIZE_AMOUNT (size)(uint64_t)(((size) < 10 * 1024 ? (size) : ((size) < 10 *
 (1024 * 1024) ? (size) / 1024 : (size) / (1024 * 1024)))), (
(size) < 10 * 1024 ? ' ' : ((size) < 10 * (1024 * 1024)
 ? 'k' : 'M')));

fprintf (file, "---------------------------------------------------------\n");
fprintf (file, fmt_str_3, "Total memory used by CFG data",
  SIZE_AMOUNT (total)(uint64_t)(((total) < 10 * 1024 ? (total) : ((total) < 10
 * (1024 * 1024) ? (total) / 1024 : (total) / (1024 * 1024)))
), ((total) < 10 * 1024 ? ' ' : ((total) < 10 * (1024 *
 1024) ? 'k' : 'M')));
fprintf (file, "---------------------------------------------------------\n");
fprintf (file, "\n");

if (cfg_stats.num_merged_labels > max_num_merged_labels)
  max_num_merged_labels = cfg_stats.num_merged_labels;

fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
  cfg_stats.num_merged_labels, max_num_merged_labels);

fprintf (file, "\n");
2699}


2702/* Dump CFG statistics on stderr.  Keep extern so that it's always
 linked in the final executable.  */

2705DEBUG_FUNCTION__attribute__ ((__used__)) void
2706debug_cfg_stats (void)
2707{
dump_cfg_stats (stderrstderr);
2709}

2711/*---------------------------------------------------------------------------
	     Miscellaneous helpers
2713---------------------------------------------------------------------------*/

2715/* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
 flow.  Transfers of control flow associated with EH are excluded.  */

2718static bool
2719call_can_make_abnormal_goto (gimple *t)
2720{
/* If the function has no non-local labels, then a call cannot make an
   abnormal transfer of control.  */
if (!cfun(cfun + 0)->has_nonlocal_label
    && !cfun(cfun + 0)->calls_setjmp)
 return false;

/* Likewise if the call has no side effects.  */
if (!gimple_has_side_effects (t))
  return false;

/* Likewise if the called function is leaf.  */
if (gimple_call_flags (t) & ECF_LEAF(1 << 10))
  return false;

return true;
2736}


2739/* Return true if T can make an abnormal transfer of control flow.
 Transfers of control flow associated with EH are excluded.  */

2742bool
2743stmt_can_make_abnormal_goto (gimple *t)
2744{
if (computed_goto_p (t))
  return true;
if (is_gimple_call (t))
  return call_can_make_abnormal_goto (t);
return false;
2750}


2753/* Return true if T represents a stmt that always transfers control.  */

2755bool
2756is_ctrl_stmt (gimple *t)
2757{
switch (gimple_code (t))
  {
  case GIMPLE_COND:
  case GIMPLE_SWITCH:
  case GIMPLE_GOTO:
  case GIMPLE_RETURN:
  case GIMPLE_RESX:
    return true;
  default:
    return false;
  }
2769}


2772/* Return true if T is a statement that may alter the flow of control
 (e.g., a call to a non-returning function).  */

2775bool
2776is_ctrl_altering_stmt (gimple *t)
2777{
gcc_assert (t)((void)(!(t) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2778, __FUNCTION__), 0 : 0));

switch (gimple_code (t))
  {
  case GIMPLE_CALL:
    /* Per stmt call flag indicates whether the call could alter
controlflow.  */
    if (gimple_call_ctrl_altering_p (t))
return true;
    break;

  case GIMPLE_EH_DISPATCH:
    /* EH_DISPATCH branches to the individual catch handlers at
this level of a try or allowed-exceptions region.  It can
fallthru to the next statement as well.  */
    return true;

  case GIMPLE_ASM:
    if (gimple_asm_nlabels (as_a <gasm *> (t)) > 0)
return true;
    break;

  CASE_GIMPLE_OMPcase GIMPLE_OMP_PARALLEL: case GIMPLE_OMP_TASK: case GIMPLE_OMP_FOR
: case GIMPLE_OMP_SECTIONS: case GIMPLE_OMP_SECTIONS_SWITCH: case
 GIMPLE_OMP_SINGLE: case GIMPLE_OMP_TARGET: case GIMPLE_OMP_TEAMS
: case GIMPLE_OMP_SCOPE: case GIMPLE_OMP_SECTION: case GIMPLE_OMP_MASTER
: case GIMPLE_OMP_MASKED: case GIMPLE_OMP_TASKGROUP: case GIMPLE_OMP_ORDERED
: case GIMPLE_OMP_CRITICAL: case GIMPLE_OMP_SCAN: case GIMPLE_OMP_RETURN
: case GIMPLE_OMP_ATOMIC_LOAD: case GIMPLE_OMP_ATOMIC_STORE: case
 GIMPLE_OMP_CONTINUE:
    /* OpenMP directives alter control flow.  */
    return true;

  case GIMPLE_TRANSACTION:
    /* A transaction start alters control flow.  */
    return true;

  default:
    break;
  }

/* If a statement can throw, it alters control flow.  */
return stmt_can_throw_internal (cfun(cfun + 0), t);
2814}


2817/* Return true if T is a simple local goto.  */

2819bool
2820simple_goto_p (gimple *t)
2821{
return (gimple_code (t) == GIMPLE_GOTO
 && TREE_CODE (gimple_goto_dest (t))((enum tree_code) (gimple_goto_dest (t))->base.code) == LABEL_DECL);
2824}


2827/* Return true if STMT should start a new basic block.  PREV_STMT is
 the statement preceding STMT.  It is used when STMT is a label or a
 case label.  Labels should only start a new basic block if their
 previous statement wasn't a label.  Otherwise, sequence of labels
 would generate unnecessary basic blocks that only contain a single
 label.  */

2834static inline bool
2835stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
2836{
if (stmt == NULLnullptr)
  return false;

/* PREV_STMT is only set to a debug stmt if the debug stmt is before
   any nondebug stmts in the block.  We don't want to start another
   block in this case: the debug stmt will already have started the
   one STMT would start if we weren't outputting debug stmts.  */
if (prev_stmt && is_gimple_debug (prev_stmt))
  return false;

/* Labels start a new basic block only if the preceding statement
   wasn't a label of the same type.  This prevents the creation of
   consecutive blocks that have nothing but a single label.  */
if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
  {
    /* Nonlocal and computed GOTO targets always start a new block.  */
    if (DECL_NONLOCAL (gimple_label_label (label_stmt))((contains_struct_check ((gimple_label_label (label_stmt)), (
TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2853, __FUNCTION__))->decl_common.nonlocal_flag)
 || FORCED_LABEL (gimple_label_label (label_stmt))((tree_check ((gimple_label_label (label_stmt)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2854, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
))
return true;

    if (glabel *plabel = safe_dyn_cast <glabel *> (prev_stmt))
{
 if (DECL_NONLOCAL (gimple_label_label (plabel))((contains_struct_check ((gimple_label_label (plabel)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2859, __FUNCTION__))->decl_common.nonlocal_flag)
     || !DECL_ARTIFICIAL (gimple_label_label (plabel))((contains_struct_check ((gimple_label_label (plabel)), (TS_DECL_COMMON
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 2860, __FUNCTION__))->decl_common.artificial_flag))
   return true;

 cfg_stats.num_merged_labels++;
 return false;
}
    else
return true;
  }
else if (gimple_code (stmt) == GIMPLE_CALL)
  {
    if (gimple_call_flags (stmt) & ECF_RETURNS_TWICE(1 << 7))
/* setjmp acts similar to a nonlocal GOTO target and thus should
  start a new block.  */
return true;
    if (gimple_call_internal_p (stmt, IFN_PHI)
 && prev_stmt
 && gimple_code (prev_stmt) != GIMPLE_LABEL
 && (gimple_code (prev_stmt) != GIMPLE_CALL
     || ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
/* PHI nodes start a new block unless preceeded by a label
  or another PHI.  */
return true;
  }

return false;
2886}


2889/* Return true if T should end a basic block.  */

2891bool
2892stmt_ends_bb_p (gimple *t)
2893{
return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
2895}

2897/* Remove block annotations and other data structures.  */

2899void
2900delete_tree_cfg_annotations (struct function *fn)
2901{
vec_free (label_to_block_map_for_fn (fn)((fn)->cfg->x_label_to_block_map));
2903}

2905/* Return the virtual phi in BB.  */

2907gphi *
2908get_virtual_phi (basic_block bb)
2909{
for (gphi_iterator gsi = gsi_start_phis (bb);
     !gsi_end_p (gsi);
     gsi_next (&gsi))
  {
    gphi *phi = gsi.phi ();

    if (virtual_operand_p (PHI_RESULT (phi)get_def_from_ptr (gimple_phi_result_ptr (phi))))
return phi;
  }

return NULLnullptr;
2921}

2923/* Return the first statement in basic block BB.  */

2925gimple *
2926first_stmt (basic_block bb)
2927{
gimple_stmt_iterator i = gsi_start_bb (bb);
gimple *stmt = NULLnullptr;

while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
  {
    gsi_next (&i);
    stmt = NULLnullptr;
  }
return stmt;
2937}

2939/* Return the first non-label statement in basic block BB.  */

2941static gimple *
2942first_non_label_stmt (basic_block bb)
2943{
gimple_stmt_iterator i = gsi_start_bb (bb);
while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
  gsi_next (&i);
return !gsi_end_p (i) ? gsi_stmt (i) : NULLnullptr;
2948}

2950/* Return the last statement in basic block BB.  */

2952gimple *
2953last_stmt (basic_block bb)
2954{
gimple_stmt_iterator i = gsi_last_bb (bb);
gimple *stmt = NULLnullptr;

while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
  {
    gsi_prev (&i);
    stmt = NULLnullptr;
  }
return stmt;
2964}

2966/* Return the last statement of an otherwise empty block.  Return NULL
 if the block is totally empty, or if it contains more than one
 statement.  */

2970gimple *
2971last_and_only_stmt (basic_block bb)
2972{
gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
gimple *last, *prev;

if (gsi_end_p (i))
  return NULLnullptr;

last = gsi_stmt (i);
gsi_prev_nondebug (&i);
if (gsi_end_p (i))
  return last;

/* Empty statements should no longer appear in the instruction stream.
   Everything that might have appeared before should be deleted by
   remove_useless_stmts, and the optimizers should just gsi_remove
   instead of smashing with build_empty_stmt.

   Thus the only thing that should appear here in a block containing
   one executable statement is a label.  */
prev = gsi_stmt (i);
if (gimple_code (prev) == GIMPLE_LABEL)
  return last;
else
  return NULLnullptr;
2996}

2998/* Returns the basic block after which the new basic block created
 by splitting edge EDGE_IN should be placed.  Tries to keep the new block
 near its "logical" location.  This is of most help to humans looking
 at debugging dumps.  */

3003basic_block
3004split_edge_bb_loc (edge edge_in)
3005{
basic_block dest = edge_in->dest;
basic_block dest_prev = dest->prev_bb;

if (dest_prev)
  {
    edge e = find_edge (dest_prev, dest);
    if (e && !(e->flags & EDGE_COMPLEX(EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE
)))
return edge_in->src;
  }
return dest_prev;
3016}

3018/* Split a (typically critical) edge EDGE_IN.  Return the new block.
 Abort on abnormal edges.  */

3021static basic_block
3022gimple_split_edge (edge edge_in)
3023{
basic_block new_bb, after_bb, dest;
edge new_edge, e;

/* Abnormal edges cannot be split.  */
gcc_assert (!(edge_in->flags & EDGE_ABNORMAL))((void)(!(!(edge_in->flags & EDGE_ABNORMAL)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3028, __FUNCTION__), 0 : 0));

dest = edge_in->dest;

after_bb = split_edge_bb_loc (edge_in);

new_bb = create_empty_bb (after_bb);
new_bb->count = edge_in->count ();

/* We want to avoid re-allocating PHIs when we first
   add the fallthru edge from new_bb to dest but we also
   want to avoid changing PHI argument order when
   first redirecting edge_in away from dest.  The former
   avoids changing PHI argument order by adding them
   last and then the redirection swapping it back into
   place by means of unordered remove.
   So hack around things by temporarily removing all PHIs
   from the destination during the edge redirection and then
   making sure the edges stay in order.  */
gimple_seq saved_phis = phi_nodes (dest);
unsigned old_dest_idx = edge_in->dest_idx;
set_phi_nodes (dest, NULLnullptr);
new_edge = make_single_succ_edge (new_bb, dest, EDGE_FALLTHRU);
e = redirect_edge_and_branch (edge_in, new_bb);
gcc_assert (e == edge_in && new_edge->dest_idx == old_dest_idx)((void)(!(e == edge_in && new_edge->dest_idx == old_dest_idx
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3052, __FUNCTION__), 0 : 0));
/* set_phi_nodes sets the BB of the PHI nodes, so do it manually here.  */
dest->il.gimple.phi_nodes = saved_phis;

return new_bb;
3057}


3060/* Verify properties of the address expression T whose base should be
 TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true.  */

3063static bool 
3064verify_address (tree t, bool verify_addressable)
3065{
bool old_constant;
bool old_side_effects;
bool new_constant;
bool new_side_effects;

old_constant = TREE_CONSTANT (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3071, __FUNCTION__))->base.constant_flag);
old_side_effects = TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3072, __FUNCTION__))->base.side_effects_flag);

recompute_tree_invariant_for_addr_expr (t);
new_side_effects = TREE_SIDE_EFFECTS (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3075, __FUNCTION__))->base.side_effects_flag);
new_constant = TREE_CONSTANT (t)((non_type_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3076, __FUNCTION__))->base.constant_flag);

if (old_constant != new_constant)
  {
    error ("constant not recomputed when %<ADDR_EXPR%> changed");
    return true;
  }
if (old_side_effects != new_side_effects)
  {
    error ("side effects not recomputed when %<ADDR_EXPR%> changed");
    return true;
  }

tree base = TREE_OPERAND (t, 0)(*((const_cast<tree*> (tree_operand_check ((t), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3089, __FUNCTION__)))));
while (handled_component_p (base))
  base = TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3091, __FUNCTION__)))));

if (!(VAR_P (base)(((enum tree_code) (base)->base.code) == VAR_DECL)
|| TREE_CODE (base)((enum tree_code) (base)->base.code) == PARM_DECL
|| TREE_CODE (base)((enum tree_code) (base)->base.code) == RESULT_DECL))
  return false;

if (verify_addressable && !TREE_ADDRESSABLE (base)((base)->base.addressable_flag))
  {
    error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
    return true;
  }

return false;
3105}


3108/* Verify if EXPR is a valid GIMPLE reference expression.  If
 REQUIRE_LVALUE is true verifies it is an lvalue.  Returns true
 if there is an error, otherwise false.  */

3112static bool
3113verify_types_in_gimple_reference (tree expr, bool require_lvalue)
3114{
const char *code_name = get_tree_code_name (TREE_CODE (expr)((enum tree_code) (expr)->base.code));

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == REALPART_EXPR
    || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == IMAGPART_EXPR
    || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == BIT_FIELD_REF)
  {
    tree op = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3121, __FUNCTION__)))));
    if (!is_gimple_reg_type (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3122, __FUNCTION__))->typed.type)))
{
 error ("non-scalar %qs", code_name);
 return true;
}

    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == BIT_FIELD_REF)
{
 tree t1 = TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3130, __FUNCTION__)))));
 tree t2 = TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3131, __FUNCTION__)))));
 poly_uint64 size, bitpos;
 if (!poly_int_tree_p (t1, &size)
     || !poly_int_tree_p (t2, &bitpos)
     || !types_compatible_p (bitsizetypesizetype_tab[(int) stk_bitsizetype], TREE_TYPE (t1)((contains_struct_check ((t1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3135, __FUNCTION__))->typed.type))
     || !types_compatible_p (bitsizetypesizetype_tab[(int) stk_bitsizetype], TREE_TYPE (t2)((contains_struct_check ((t2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3136, __FUNCTION__))->typed.type)))
   {
     error ("invalid position or size operand to %qs", code_name);
     return true;
   }
 if (INTEGRAL_TYPE_P (TREE_TYPE (expr))(((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3141, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3141, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3141, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3142, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3142, __FUNCTION__))->type_common.precision), size))
   {
     error ("integral result type precision does not match "
     "field size of %qs", code_name);
     return true;
   }
 else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))(((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3148, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3148, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3148, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
   && TYPE_MODE (TREE_TYPE (expr))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3149, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3149, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3149, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3149, __FUNCTION__))->typed.type))->type_common.mode) != BLKmode((void) 0, E_BLKmode)
   && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))((((enum tree_code) ((tree_class_check ((((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3150, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3150, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3150, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3150, __FUNCTION__))->typed.type))->type_common.mode)),
		size))
   {
     error ("mode size of non-integral result does not "
     "match field size of %qs",
     code_name);
     return true;
   }
 if (INTEGRAL_TYPE_P (TREE_TYPE (op))(((enum tree_code) (((contains_struct_check ((op), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3158, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3158, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3158, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && !type_has_mode_precision_p (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3159, __FUNCTION__))->typed.type)))
   {
     error ("%qs of non-mode-precision operand", code_name);
     return true;
   }
 if (!AGGREGATE_TYPE_P (TREE_TYPE (op))(((enum tree_code) (((contains_struct_check ((op), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3164, __FUNCTION__))->typed.type))->base.code) == ARRAY_TYPE
 || (((enum tree_code) (((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3164, __FUNCTION__))->typed.type))->base.code) == RECORD_TYPE
 || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3164, __FUNCTION__))->typed.type))->base.code) == UNION_TYPE
 || ((enum tree_code) (((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3164, __FUNCTION__))->typed.type))->base.code) == QUAL_UNION_TYPE
))
     && maybe_gt (size + bitpos,maybe_lt (tree_to_poly_uint64 (((tree_class_check ((((contains_struct_check
 ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3166, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3166, __FUNCTION__))->type_common.size)), size + bitpos)
	   tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op))))maybe_lt (tree_to_poly_uint64 (((tree_class_check ((((contains_struct_check
 ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3166, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3166, __FUNCTION__))->type_common.size)), size + bitpos))
   {
     error ("position plus size exceeds size of referenced object in "
     "%qs", code_name);
     return true;
   }
}

    if ((TREE_CODE (expr)((enum tree_code) (expr)->base.code) == REALPART_EXPR
  || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == IMAGPART_EXPR)
 && !useless_type_conversion_p (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3176, __FUNCTION__))->typed.type),
			 TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3177, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3177, __FUNCTION__))->typed.type)))
{
 error ("type mismatch in %qs reference", code_name);
 debug_generic_stmt (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3180, __FUNCTION__))->typed.type));
 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3181, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3181, __FUNCTION__))->typed.type));
 return true;
}
    expr = op;
  }

while (handled_component_p (expr))
  {
    code_name = get_tree_code_name (TREE_CODE (expr)((enum tree_code) (expr)->base.code));

    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == REALPART_EXPR
 || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == IMAGPART_EXPR
 || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == BIT_FIELD_REF)
{
 error ("non-top-level %qs", code_name);
 return true;
}

    tree op = TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3199, __FUNCTION__)))));

    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_REF
 || TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_RANGE_REF)
{
 if (!is_gimple_val (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3204, __FUNCTION__))))))
     || (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3205, __FUNCTION__)))))
  && !is_gimple_val (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3206, __FUNCTION__)))))))
     || (TREE_OPERAND (expr, 3)(*((const_cast<tree*> (tree_operand_check ((expr), (3),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3207, __FUNCTION__)))))
  && !is_gimple_val (TREE_OPERAND (expr, 3)(*((const_cast<tree*> (tree_operand_check ((expr), (3),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3208, __FUNCTION__))))))))
   {
     error ("invalid operands to %qs", code_name);
     debug_generic_stmt (expr);
     return true;
   }
}

    /* Verify if the reference array element types are compatible.  */
    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_REF
 && !useless_type_conversion_p (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3218, __FUNCTION__))->typed.type),
			 TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3219, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3219, __FUNCTION__))->typed.type)))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_stmt (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3222, __FUNCTION__))->typed.type));
 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3223, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3223, __FUNCTION__))->typed.type));
 return true;
}
    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == ARRAY_RANGE_REF
 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr))((contains_struct_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3227, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3227, __FUNCTION__))->typed.type),
			 TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3228, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3228, __FUNCTION__))->typed.type)))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr))((contains_struct_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3231, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3231, __FUNCTION__))->typed.type));
 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op))((contains_struct_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3232, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3232, __FUNCTION__))->typed.type));
 return true;
}

    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == COMPONENT_REF)
{
 if (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3238, __FUNCTION__)))))
     && !is_gimple_val (TREE_OPERAND (expr, 2)(*((const_cast<tree*> (tree_operand_check ((expr), (2),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3239, __FUNCTION__)))))))
   {
     error ("invalid %qs offset operator", code_name);
     return true;
   }
 if (!useless_type_conversion_p (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3244, __FUNCTION__))->typed.type),
			  TREE_TYPE (TREE_OPERAND (expr, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3245, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3245, __FUNCTION__))->typed.type)))
   {
     error ("type mismatch in %qs", code_name);
     debug_generic_stmt (TREE_TYPE (expr)((contains_struct_check ((expr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3248, __FUNCTION__))->typed.type));
     debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3249, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3249, __FUNCTION__))->typed.type));
     return true;
   }
}

    if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == VIEW_CONVERT_EXPR)
{
 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
    that their operand is not an SSA name or an invariant when
    requiring an lvalue (this usually means there is a SRA or IPA-SRA
    bug).  Otherwise there is nothing to verify, gross mismatches at
    most invoke undefined behavior.  */
 if (require_lvalue
     && (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME
  || is_gimple_min_invariant (op)))
   {
     error ("conversion of %qs on the left hand side of %qs",
     get_tree_code_name (TREE_CODE (op)((enum tree_code) (op)->base.code)), code_name);
     debug_generic_stmt (expr);
     return true;
   }
 else if (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME
   && TYPE_SIZE (TREE_TYPE (expr))((tree_class_check ((((contains_struct_check ((expr), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3271, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3271, __FUNCTION__))->type_common.size) != TYPE_SIZE (TREE_TYPE (op))((tree_class_check ((((contains_struct_check ((op), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3271, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3271, __FUNCTION__))->type_common.size))
   {
     error ("conversion of register to a different size in %qs",
     code_name);
     debug_generic_stmt (expr);
     return true;
   }
 else if (!handled_component_p (op))
   return false;
}

    expr = op;
  }

code_name = get_tree_code_name (TREE_CODE (expr)((enum tree_code) (expr)->base.code));

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == MEM_REF)
  {
    if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3289, __FUNCTION__))))))
 || (TREE_CODE (TREE_OPERAND (expr, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((expr), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3290, __FUNCTION__))))))->base.code) == ADDR_EXPR
     && verify_address (TREE_OPERAND (expr, 0)(*((const_cast<tree*> (tree_operand_check ((expr), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3291, __FUNCTION__))))), false)))
{
 error ("invalid address operand in %qs", code_name);
 debug_generic_stmt (expr);
 return true;
}
    if (!poly_int_tree_p (TREE_OPERAND (expr, 1)(*((const_cast<tree*> (tree_operand_check ((expr), (1),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3297, __FUNCTION__))))))
 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1)))(((enum tree_code) (((contains_struct_check (((*((const_cast<
tree*> (tree_operand_check ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3298, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3298, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((expr), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3298, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3298, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 error ("invalid offset operand in %qs", code_name);
 debug_generic_stmt (expr);
 return true;
}
    if (MR_DEPENDENCE_CLIQUE (expr)((tree_check2 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3304, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) != 0
 && MR_DEPENDENCE_CLIQUE (expr)((tree_check2 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3305, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) > cfun(cfun + 0)->last_clique)
{
 error ("invalid clique in %qs", code_name);
 debug_generic_stmt (expr);
 return true;
}
  }
else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == TARGET_MEM_REF)
  {
    if (!TMR_BASE (expr)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3314, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3314, __FUNCTION__))))))
 || !is_gimple_mem_ref_addr (TMR_BASE (expr)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3315, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3315, __FUNCTION__)))))))
 || (TREE_CODE (TMR_BASE (expr))((enum tree_code) (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3316, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3316, __FUNCTION__)))))))->base.code) == ADDR_EXPR
     && verify_address (TMR_BASE (expr)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3317, __FUNCTION__, (TARGET_MEM_REF)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3317, __FUNCTION__)))))), false)))
{
 error ("invalid address operand in %qs", code_name);
 return true;
}
    if (!TMR_OFFSET (expr)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3322, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3322, __FUNCTION__))))))
 || !poly_int_tree_p (TMR_OFFSET (expr)((*((const_cast<tree*> (tree_operand_check (((tree_check
 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3323, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3323, __FUNCTION__)))))))
 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr)))(((enum tree_code) (((contains_struct_check ((((*((const_cast
<tree*> (tree_operand_check (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((((*((const_cast
<tree*> (tree_operand_check (((tree_check ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__, (TARGET_MEM_REF)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__))))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3324, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
 error ("invalid offset operand in %qs", code_name);
 debug_generic_stmt (expr);
 return true;
}
    if (MR_DEPENDENCE_CLIQUE (expr)((tree_check2 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3330, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) != 0
 && MR_DEPENDENCE_CLIQUE (expr)((tree_check2 ((expr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3331, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) > cfun(cfun + 0)->last_clique)
{
 error ("invalid clique in %qs", code_name);
 debug_generic_stmt (expr);
 return true;
}
  }
else if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == INDIRECT_REF)
  {
    error ("%qs in gimple IL", code_name);
    debug_generic_stmt (expr);
    return true;
  }

if (!require_lvalue
    && (TREE_CODE (expr)((enum tree_code) (expr)->base.code) == SSA_NAME || is_gimple_min_invariant (expr)))
  return false;

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) != SSA_NAME && is_gimple_id (expr))
  return false;

if (TREE_CODE (expr)((enum tree_code) (expr)->base.code) != TARGET_MEM_REF
    && TREE_CODE (expr)((enum tree_code) (expr)->base.code) != MEM_REF)
  {
    error ("invalid expression for min lvalue");
    return true;
  }

return false;
3360}

3362/* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
 list of pointer-to types that is trivially convertible to DEST.  */

3365static bool
3366one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
3367{
tree src;

if (!TYPE_POINTER_TO (src_obj)((tree_class_check ((src_obj), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3370, __FUNCTION__))->type_common.pointer_to))
  return true;

for (src = TYPE_POINTER_TO (src_obj)((tree_class_check ((src_obj), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3373, __FUNCTION__))->type_common.pointer_to); src; src = TYPE_NEXT_PTR_TO (src)((tree_check ((src), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3373, __FUNCTION__, (POINTER_TYPE)))->type_non_common.minval
))
  if (useless_type_conversion_p (dest, src))
    return true;

return false;
3378}

3380/* Return true if TYPE1 is a fixed-point type and if conversions to and
 from TYPE2 can be handled by FIXED_CONVERT_EXPR.  */

3383static bool
3384valid_fixed_convert_types_p (tree type1, tree type2)
3385{
return (FIXED_POINT_TYPE_P (type1)(((enum tree_code) (type1)->base.code) == FIXED_POINT_TYPE
)
 && (INTEGRAL_TYPE_P (type2)(((enum tree_code) (type2)->base.code) == ENUMERAL_TYPE ||
 ((enum tree_code) (type2)->base.code) == BOOLEAN_TYPE || (
(enum tree_code) (type2)->base.code) == INTEGER_TYPE)
     || SCALAR_FLOAT_TYPE_P (type2)(((enum tree_code) (type2)->base.code) == REAL_TYPE)
     || FIXED_POINT_TYPE_P (type2)(((enum tree_code) (type2)->base.code) == FIXED_POINT_TYPE
)));
3390}

3392/* Verify the contents of a GIMPLE_CALL STMT.  Returns true when there
 is a problem, otherwise false.  */

3395static bool
3396verify_gimple_call (gcall *stmt)
3397{
tree fn = gimple_call_fn (stmt);
tree fntype, fndecl;
unsigned i;

if (gimple_call_internal_p (stmt))
  {
    if (fn)
{
 error ("gimple call has two targets");
 debug_generic_stmt (fn);
 return true;
}
  }
else
  {
    if (!fn)
{
 error ("gimple call has no target");
 return true;
}
  }

if (fn && !is_gimple_call_addr (fn))
  {
    error ("invalid function in gimple call");
    debug_generic_stmt (fn);
    return true;
  }

if (fn
    && (!POINTER_TYPE_P (TREE_TYPE (fn))(((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3428, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fn), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3428, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3429, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3429, __FUNCTION__))->typed.type))->base.code) != FUNCTION_TYPE
     && TREE_CODE (TREE_TYPE (TREE_TYPE (fn)))((enum tree_code) (((contains_struct_check ((((contains_struct_check
 ((fn), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3430, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3430, __FUNCTION__))->typed.type))->base.code) != METHOD_TYPE)))
  {
    error ("non-function in gimple call");
    return true;
  }

 fndecl = gimple_call_fndecl (stmt);
 if (fndecl
     && TREE_CODE (fndecl)((enum tree_code) (fndecl)->base.code) == FUNCTION_DECL
     && DECL_LOOPING_CONST_OR_PURE_P (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3439, __FUNCTION__, (FUNCTION_DECL)))->function_decl.looping_const_or_pure_flag
)
     && !DECL_PURE_P (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3440, __FUNCTION__, (FUNCTION_DECL)))->function_decl.pure_flag
)
     && !TREE_READONLY (fndecl)((non_type_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3441, __FUNCTION__))->base.readonly_flag))
   {
     error ("invalid pure const state for function");
     return true;
   }

tree lhs = gimple_call_lhs (stmt);
if (lhs
    && (!is_gimple_reg (lhs)
 && (!is_gimple_lvalue (lhs)
     || verify_types_in_gimple_reference
   (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == WITH_SIZE_EXPR
    ? TREE_OPERAND (lhs, 0)(*((const_cast<tree*> (tree_operand_check ((lhs), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3453, __FUNCTION__))))) : lhs, true))))
  {
    error ("invalid LHS in gimple call");
    return true;
  }

if (gimple_call_ctrl_altering_p (stmt)
    && gimple_call_noreturn_p (stmt)
    && should_remove_lhs_p (lhs))
  {
    error ("LHS in %<noreturn%> call");
    return true;
  }

fntype = gimple_call_fntype (stmt);
if (fntype
    && lhs
    && !useless_type_conversion_p (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3470, __FUNCTION__))->typed.type), TREE_TYPE (fntype)((contains_struct_check ((fntype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3470, __FUNCTION__))->typed.type))
    /* ???  At least C++ misses conversions at assignments from
void * call results.
For now simply allow arbitrary pointer type conversions.  */
    && !(POINTER_TYPE_P (TREE_TYPE (lhs))(((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3474, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3474, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
  && POINTER_TYPE_P (TREE_TYPE (fntype))(((enum tree_code) (((contains_struct_check ((fntype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3475, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fntype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3475, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)))
  {
    error ("invalid conversion in gimple call");
    debug_generic_stmt (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3478, __FUNCTION__))->typed.type));
    debug_generic_stmt (TREE_TYPE (fntype)((contains_struct_check ((fntype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3479, __FUNCTION__))->typed.type));
    return true;
  }

if (gimple_call_chain (stmt)
    && !is_gimple_val (gimple_call_chain (stmt)))
  {
    error ("invalid static chain in gimple call");
    debug_generic_stmt (gimple_call_chain (stmt));
    return true;
  }

/* If there is a static chain argument, the call should either be
   indirect, or the decl should have DECL_STATIC_CHAIN set.  */
if (gimple_call_chain (stmt)
    && fndecl
    && !DECL_STATIC_CHAIN (fndecl)((tree_check ((fndecl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3495, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
))
  {
    error ("static chain with function that doesn%'t use one");
    return true;
  }

if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
  {
    switch (DECL_FUNCTION_CODE (fndecl))
{
case BUILT_IN_UNREACHABLE:
case BUILT_IN_UNREACHABLE_TRAP:
case BUILT_IN_TRAP:
 if (gimple_call_num_args (stmt) > 0)
   {
     /* Built-in unreachable with parameters might not be caught by
 undefined behavior sanitizer.  Front-ends do check users do not
 call them that way but we also produce calls to
 __builtin_unreachable internally, for example when IPA figures
 out a call cannot happen in a legal program.  In such cases,
 we must make sure arguments are stripped off.  */
     error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
     "with arguments");
     return true;
   }
 break;
default:
 break;
}
  }

/* For a call to .DEFERRED_INIT,
   LHS = DEFERRED_INIT (SIZE of the DECL, INIT_TYPE, NAME of the DECL)
   we should guarantee that when the 1st argument is a constant, it should
   be the same as the size of the LHS.  */

if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
  {
    tree size_of_arg0 = gimple_call_arg (stmt, 0);
    tree size_of_lhs = TYPE_SIZE_UNIT (TREE_TYPE (lhs))((tree_class_check ((((contains_struct_check ((lhs), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3534, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3534, __FUNCTION__))->type_common.size_unit);

    if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == SSA_NAME)
lhs = SSA_NAME_VAR (lhs)((tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3537, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((lhs)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (lhs)->ssa_name
.var);

    poly_uint64 size_from_arg0, size_from_lhs;
    bool is_constant_size_arg0 = poly_int_tree_p (size_of_arg0,
				    &size_from_arg0);
    bool is_constant_size_lhs = poly_int_tree_p (size_of_lhs,
				   &size_from_lhs);
    if (is_constant_size_arg0 && is_constant_size_lhs)
if (maybe_ne (size_from_arg0, size_from_lhs))
 {
   error ("%<DEFERRED_INIT%> calls should have same "
   "constant size for the first argument and LHS");
   return true;
 }
  }

/* ???  The C frontend passes unpromoted arguments in case it
   didn't see a function declaration before the call.  So for now
   leave the call arguments mostly unverified.  Once we gimplify
   unit-at-a-time we have a chance to fix this.  */
for (i = 0; i < gimple_call_num_args (stmt); ++i)
  {
    tree arg = gimple_call_arg (stmt, i);
    if ((is_gimple_reg_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3560, __FUNCTION__))->typed.type))
  && !is_gimple_val (arg))
 || (!is_gimple_reg_type (TREE_TYPE (arg)((contains_struct_check ((arg), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3562, __FUNCTION__))->typed.type))
     && !is_gimple_lvalue (arg)))
{
 error ("invalid argument to gimple call");
 debug_generic_expr (arg);
 return true;
}
    if (!is_gimple_reg (arg))
{
 if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == WITH_SIZE_EXPR)
   arg = TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3572, __FUNCTION__)))));
 if (verify_types_in_gimple_reference (arg, false))
   return true;
}
  }

return false;
3579}

3581/* Verifies the gimple comparison with the result type TYPE and
 the operands OP0 and OP1, comparison code is CODE.  */

3584static bool
3585verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
3586{
tree op0_type = TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3587, __FUNCTION__))->typed.type);
tree op1_type = TREE_TYPE (op1)((contains_struct_check ((op1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3588, __FUNCTION__))->typed.type);

if (!is_gimple_val (op0) || !is_gimple_val (op1))
  {
    error ("invalid operands in gimple comparison");
    return true;
  }

/* For comparisons we do not have the operations type as the
   effective type the comparison is carried out in.  Instead
   we require that either the first operand is trivially
   convertible into the second, or the other way around.  */
if (!useless_type_conversion_p (op0_type, op1_type)
    && !useless_type_conversion_p (op1_type, op0_type))
  {
    error ("mismatching comparison operand types");
    debug_generic_expr (op0_type);
    debug_generic_expr (op1_type);
    return true;
  }

/* The resulting type of a comparison may be an effective boolean type.  */
if (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)
    && (TREE_CODE (type)((enum tree_code) (type)->base.code) == BOOLEAN_TYPE
 || TYPE_PRECISION (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3612, __FUNCTION__))->type_common.precision) == 1))
  {
    if ((TREE_CODE (op0_type)((enum tree_code) (op0_type)->base.code) == VECTOR_TYPE
  || TREE_CODE (op1_type)((enum tree_code) (op1_type)->base.code) == VECTOR_TYPE)
 && code != EQ_EXPR && code != NE_EXPR
 && !VECTOR_BOOLEAN_TYPE_P (op0_type)(((enum tree_code) (op0_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((op0_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3617, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
 && !VECTOR_INTEGER_TYPE_P (op0_type)((((enum tree_code) (op0_type)->base.code) == VECTOR_TYPE)
 && ((enum tree_code) (((contains_struct_check ((op0_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3618, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
{
 error ("unsupported operation or type for vector comparison"
 " returning a boolean");
 debug_generic_expr (op0_type);
 debug_generic_expr (op1_type);
 return true;
      }
  }
/* Or a boolean vector type with the same element count
   as the comparison operand types.  */
else if (TREE_CODE (type)((enum tree_code) (type)->base.code) == VECTOR_TYPE
  && TREE_CODE (TREE_TYPE (type))((enum tree_code) (((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3630, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE)
  {
    if (TREE_CODE (op0_type)((enum tree_code) (op0_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (op1_type)((enum tree_code) (op1_type)->base.code) != VECTOR_TYPE)
      {
        error ("non-vector operands in vector comparison");
        debug_generic_expr (op0_type);
        debug_generic_expr (op1_type);
        return true;
      }

    if (maybe_ne (TYPE_VECTOR_SUBPARTS (type),
    TYPE_VECTOR_SUBPARTS (op0_type)))
      {
        error ("invalid vector comparison resulting type");
        debug_generic_expr (type);
        return true;
      }
  }
else
  {
    error ("bogus comparison result type");
    debug_generic_expr (type);
    return true;
  }

return false;
3657}

3659/* Verify a gimple assignment statement STMT with an unary rhs.
 Returns true if anything is wrong.  */

3662static bool
3663verify_gimple_assign_unary (gassign *stmt)
3664{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3667, __FUNCTION__))->typed.type);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3669, __FUNCTION__))->typed.type);

if (!is_gimple_reg (lhs))
  {
    error ("non-register as LHS of unary operation");
    return true;
  }

if (!is_gimple_val (rhs1))
  {
    error ("invalid operand in unary operation");
    return true;
  }

const char* const code_name = get_tree_code_name (rhs_code);

/* First handle conversions.  */
switch (rhs_code)
  {
  CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR:
    {
/* Allow conversions between vectors with the same number of elements,
  provided that the conversion is OK for the element types too.  */
if (VECTOR_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE)
   && VECTOR_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE)
   && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (lhs_type), TYPE_VECTOR_SUBPARTS
 (rhs1_type)))
	 TYPE_VECTOR_SUBPARTS (rhs1_type))(!maybe_ne (TYPE_VECTOR_SUBPARTS (lhs_type), TYPE_VECTOR_SUBPARTS
 (rhs1_type))))
 {
   lhs_type = TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3697, __FUNCTION__))->typed.type);
   rhs1_type = TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3698, __FUNCTION__))->typed.type);
 }
else if (VECTOR_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE) || VECTOR_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE))
 {
   error ("invalid vector types in nop conversion");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

/* Allow conversions from pointer type to integral type only if
  there is no sign or zero extension involved.
  For targets were the precision of ptrofftype doesn't match that
  of pointers we allow conversions to types where
  POINTERS_EXTEND_UNSIGNED specifies how that works.  */
if ((POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
    && INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
))
   || (POINTER_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == REFERENCE_TYPE
)
&& INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
&& (TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3717, __FUNCTION__))->type_common.precision) >= TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3717, __FUNCTION__))->type_common.precision)
3718#if defined(POINTERS_EXTEND_UNSIGNED1)
    || (TYPE_MODE (rhs1_type)((((enum tree_code) ((tree_class_check ((rhs1_type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3719, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (rhs1_type) : (rhs1_type)->type_common.mode) == ptr_mode
	&& (TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3720, __FUNCTION__))->type_common.precision)
	      == BITS_PER_WORD((8) * (((global_options.x_ix86_isa_flags & (1UL <<
 1)) != 0) ? 8 : 4)) /* word_mode */
	    || (TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3722, __FUNCTION__))->type_common.precision)
		  == GET_MODE_PRECISION (Pmode(global_options.x_ix86_pmode == PMODE_DI ? (scalar_int_mode (
(scalar_int_mode::from_int) E_DImode)) : (scalar_int_mode ((scalar_int_mode
::from_int) E_SImode)))))))
3724#endif
   )))
 return false;

/* Allow conversion from integral to offset type and vice versa.  */
if ((TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) == OFFSET_TYPE
    && INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
))
   || (INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
&& TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) == OFFSET_TYPE))
 return false;

/* Otherwise assert we are converting between types of the
  same kind.  */
if (INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
) != INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
))
 {
   error ("invalid types in nop conversion");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

return false;
    }

  case ADDR_SPACE_CONVERT_EXPR:
    {
if (!POINTER_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == REFERENCE_TYPE
) || !POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
   || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))((tree_class_check ((((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3751, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3751, __FUNCTION__))->base.u.bits.address_space)
== TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))((tree_class_check ((((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3752, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3752, __FUNCTION__))->base.u.bits.address_space)))
 {
   error ("invalid types in address space conversion");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

return false;
    }

  case FIXED_CONVERT_EXPR:
    {
if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
   && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
 {
   error ("invalid types in fixed-point conversion");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

return false;
    }

  case FLOAT_EXPR:
    {
if ((!INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
) || !SCALAR_FLOAT_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == REAL_TYPE))
   && (!VECTOR_INTEGER_TYPE_P (rhs1_type)((((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE
) && ((enum tree_code) (((contains_struct_check ((rhs1_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3780, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
       || !VECTOR_FLOAT_TYPE_P (lhs_type)((((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE)
 && ((enum tree_code) (((contains_struct_check ((lhs_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3781, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
 {
   error ("invalid types in conversion to floating-point");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

      return false;
    }

  case FIX_TRUNC_EXPR:
    {
      if ((!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
) || !SCALAR_FLOAT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == REAL_TYPE))
          && (!VECTOR_INTEGER_TYPE_P (lhs_type)((((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE)
 && ((enum tree_code) (((contains_struct_check ((lhs_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3795, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
              || !VECTOR_FLOAT_TYPE_P (rhs1_type)((((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE
) && ((enum tree_code) (((contains_struct_check ((rhs1_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3796, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
 {
   error ("invalid types in conversion to integer");
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   return true;
 }

      return false;
    }

  case VEC_UNPACK_HI_EXPR:
  case VEC_UNPACK_LO_EXPR:
  case VEC_UNPACK_FLOAT_HI_EXPR:
  case VEC_UNPACK_FLOAT_LO_EXPR:
  case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
  case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
    if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
        || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
        || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3815, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3815, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3815, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3816, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
))
        || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3817, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3817, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3817, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3818, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
))
 || ((rhs_code == VEC_UNPACK_HI_EXPR
      || rhs_code == VEC_UNPACK_LO_EXPR)
     && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3821, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3821, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3821, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
  != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3822, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3822, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3822, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
 || ((rhs_code == VEC_UNPACK_FLOAT_HI_EXPR
      || rhs_code == VEC_UNPACK_FLOAT_LO_EXPR)
     && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3825, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3825, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3825, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
  || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3826, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
 || ((rhs_code == VEC_UNPACK_FIX_TRUNC_HI_EXPR
      || rhs_code == VEC_UNPACK_FIX_TRUNC_LO_EXPR)
     && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3829, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3829, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3829, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
  || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3830, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)))
 || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
	2 * GET_MODE_SIZE (element_mode (rhs1_type)))
     && (!VECTOR_BOOLEAN_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3833, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
  || !VECTOR_BOOLEAN_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3834, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)))
 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type),
       TYPE_VECTOR_SUBPARTS (rhs1_type)))
{
 error ("type mismatch in %qs expression", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
      }

    return false;

  case NEGATE_EXPR:
  case ABS_EXPR:
  case BIT_NOT_EXPR:
  case PAREN_EXPR:
  case CONJ_EXPR:
    /* Disallow pointer and offset types for many of the unary gimple. */
    if (POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
 || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) == OFFSET_TYPE)
{
 error ("invalid types for %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
}
    break;

  case ABSU_EXPR:
    if (!ANY_INTEGRAL_TYPE_P (lhs_type)((((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
) || ((((enum tree_code) (lhs_type)->base.code) == COMPLEX_TYPE
 || (((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE
)) && (((enum tree_code) (((contains_struct_check ((lhs_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3863, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3863, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3863, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
 || !TYPE_UNSIGNED (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3864, __FUNCTION__))->base.u.bits.unsigned_flag)
 || !ANY_INTEGRAL_TYPE_P (rhs1_type)((((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
) || ((((enum tree_code) (rhs1_type)->base.code) == COMPLEX_TYPE
 || (((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE
)) && (((enum tree_code) (((contains_struct_check ((rhs1_type
), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3865, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3865, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3865, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
 || TYPE_UNSIGNED (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3866, __FUNCTION__))->base.u.bits.unsigned_flag)
 || element_precision (lhs_type) != element_precision (rhs1_type))
{
 error ("invalid types for %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
}
    return false;

  case VEC_DUPLICATE_EXPR:
    if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
 || !useless_type_conversion_p (TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3878, __FUNCTION__))->typed.type), rhs1_type))
{
 error ("%qs should be from a scalar to a like vector", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
}
    return false;

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3888, __FUNCTION__));
  }

/* For the remaining codes assert there is no conversion involved.  */
if (!useless_type_conversion_p (lhs_type, rhs1_type))
  {
    error ("non-trivial conversion in unary operation");
    debug_generic_expr (lhs_type);
    debug_generic_expr (rhs1_type);
    return true;
  }

return false;
3901}

3903/* Verify a gimple assignment statement STMT with a binary rhs.
 Returns true if anything is wrong.  */

3906static bool
3907verify_gimple_assign_binary (gassign *stmt)
3908{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3911, __FUNCTION__))->typed.type);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3913, __FUNCTION__))->typed.type);
tree rhs2 = gimple_assign_rhs2 (stmt);
tree rhs2_type = TREE_TYPE (rhs2)((contains_struct_check ((rhs2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3915, __FUNCTION__))->typed.type);

if (!is_gimple_reg (lhs))
  {
    error ("non-register as LHS of binary operation");
    return true;
  }

if (!is_gimple_val (rhs1)
    || !is_gimple_val (rhs2))
  {
    error ("invalid operands in binary operation");
    return true;
  }

const char* const code_name = get_tree_code_name (rhs_code);

/* First handle operations that involve different types.  */
switch (rhs_code)
  {
  case COMPLEX_EXPR:
    {
if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != COMPLEX_TYPE
   || !(INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
        || SCALAR_FLOAT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == REAL_TYPE))
   || !(INTEGRAL_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == INTEGER_TYPE
)
        || SCALAR_FLOAT_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == REAL_TYPE)))
 {
   error ("type mismatch in %qs", code_name);
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   debug_generic_expr (rhs2_type);
   return true;
 }

return false;
    }

  case LSHIFT_EXPR:
  case RSHIFT_EXPR:
  case LROTATE_EXPR:
  case RROTATE_EXPR:
    {
/* Shifts and rotates are ok on integral types, fixed point
  types and integer vector types.  */
if ((!INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
    && !FIXED_POINT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == FIXED_POINT_TYPE
)
    && !(TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE
  && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3963, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3963, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3963, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
   || (!INTEGRAL_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == INTEGER_TYPE
)
/* Vector shifts of vectors are also ok.  */
&& !(TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE
     && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3967, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3967, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3967, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     && TREE_CODE (rhs2_type)((enum tree_code) (rhs2_type)->base.code) == VECTOR_TYPE
     && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))(((enum tree_code) (((contains_struct_check ((rhs2_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3969, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs2_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3969, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs2_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3969, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
   || !useless_type_conversion_p (lhs_type, rhs1_type))
 {
   error ("type mismatch in %qs", code_name);
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   debug_generic_expr (rhs2_type);
   return true;
 }

return false;
    }

  case WIDEN_LSHIFT_EXPR:
    {
      if (!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
          || !INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
          || TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) != INTEGER_CST
          || (2 * TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3987, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 3987, __FUNCTION__))->type_common.precision)))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }

      return false;
    }

  case VEC_WIDEN_LSHIFT_HI_EXPR:
  case VEC_WIDEN_LSHIFT_LO_EXPR:
    {
      if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
          || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
          || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4004, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4004, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4004, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
          || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4005, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4005, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4005, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
          || TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) != INTEGER_CST
          || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))((tree_class_check ((((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4007, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4007, __FUNCTION__))->type_common.precision)
              > TYPE_PRECISION (TREE_TYPE (lhs_type))((tree_class_check ((((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4008, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4008, __FUNCTION__))->type_common.precision)))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }

      return false;
    }

  case WIDEN_PLUS_EXPR:
  case WIDEN_MINUS_EXPR:
  case PLUS_EXPR:
  case MINUS_EXPR:
    {
tree lhs_etype = lhs_type;
tree rhs1_etype = rhs1_type;
tree rhs2_etype = rhs2_type;
if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE)
 {
   if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
|| TREE_CODE (rhs2_type)((enum tree_code) (rhs2_type)->base.code) != VECTOR_TYPE)
     {
error ("invalid non-vector operands to %qs", code_name);
return true;
     }
   lhs_etype = TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4036, __FUNCTION__))->typed.type);
   rhs1_etype = TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4037, __FUNCTION__))->typed.type);
   rhs2_etype = TREE_TYPE (rhs2_type)((contains_struct_check ((rhs2_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4038, __FUNCTION__))->typed.type);
 }
if (POINTER_TYPE_P (lhs_etype)(((enum tree_code) (lhs_etype)->base.code) == POINTER_TYPE
 || ((enum tree_code) (lhs_etype)->base.code) == REFERENCE_TYPE
)
   || POINTER_TYPE_P (rhs1_etype)(((enum tree_code) (rhs1_etype)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs1_etype)->base.code) == REFERENCE_TYPE
)
   || POINTER_TYPE_P (rhs2_etype)(((enum tree_code) (rhs2_etype)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs2_etype)->base.code) == REFERENCE_TYPE
))
 {
   error ("invalid (pointer) operands %qs", code_name);
   return true;
 }

/* Continue with generic binary expression handling.  */
break;
    }

  case POINTER_PLUS_EXPR:
    {
if (!POINTER_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == REFERENCE_TYPE
)
   || !useless_type_conversion_p (lhs_type, rhs1_type)
   || !ptrofftype_p (rhs2_type))
 {
   error ("type mismatch in %qs", code_name);
   debug_generic_stmt (lhs_type);
   debug_generic_stmt (rhs1_type);
   debug_generic_stmt (rhs2_type);
   return true;
 }

return false;
    }

  case POINTER_DIFF_EXPR:
    {
if (!POINTER_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == REFERENCE_TYPE
)
   || !POINTER_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == REFERENCE_TYPE
)
   /* Because we special-case pointers to void we allow difference
      of arbitrary pointers with the same mode.  */
   || TYPE_MODE (rhs1_type)((((enum tree_code) ((tree_class_check ((rhs1_type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4074, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (rhs1_type) : (rhs1_type)->type_common.mode) != TYPE_MODE (rhs2_type)((((enum tree_code) ((tree_class_check ((rhs2_type), (tcc_type
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4074, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (rhs2_type) : (rhs2_type)->type_common.mode)
   || !INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
   || TYPE_UNSIGNED (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4076, __FUNCTION__))->base.u.bits.unsigned_flag)
   || TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4077, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4077, __FUNCTION__))->type_common.precision))
 {
   error ("type mismatch in %qs", code_name);
   debug_generic_stmt (lhs_type);
   debug_generic_stmt (rhs1_type);
   debug_generic_stmt (rhs2_type);
   return true;
 }

return false;
    }

  case TRUTH_ANDIF_EXPR:
  case TRUTH_ORIF_EXPR:
  case TRUTH_AND_EXPR:
  case TRUTH_OR_EXPR:
  case TRUTH_XOR_EXPR:

    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4095, __FUNCTION__));

  case LT_EXPR:
  case LE_EXPR:
  case GT_EXPR:
  case GE_EXPR:
  case EQ_EXPR:
  case NE_EXPR:
  case UNORDERED_EXPR:
  case ORDERED_EXPR:
  case UNLT_EXPR:
  case UNLE_EXPR:
  case UNGT_EXPR:
  case UNGE_EXPR:
  case UNEQ_EXPR:
  case LTGT_EXPR:
    /* Comparisons are also binary, but the result type is not
connected to the operand types.  */
    return verify_gimple_comparison (lhs_type, rhs1, rhs2, rhs_code);

  case WIDEN_MULT_EXPR:
    if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != INTEGER_TYPE)
return true;
    return ((2 * TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4118, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4118, __FUNCTION__))->type_common.precision))
     || (TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4119, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4119, __FUNCTION__))->type_common.precision)));

  case WIDEN_SUM_EXPR:
    {
      if (((TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
     || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE)
    && ((!INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
  && !SCALAR_FLOAT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == REAL_TYPE))
 || (!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
     && !SCALAR_FLOAT_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == REAL_TYPE))))
   || !useless_type_conversion_p (lhs_type, rhs2_type)
   || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type)),
	 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }
      return false;
    }

  case VEC_WIDEN_MINUS_HI_EXPR:
  case VEC_WIDEN_MINUS_LO_EXPR:
  case VEC_WIDEN_PLUS_HI_EXPR:
  case VEC_WIDEN_PLUS_LO_EXPR:
  case VEC_WIDEN_MULT_HI_EXPR:
  case VEC_WIDEN_MULT_LO_EXPR:
  case VEC_WIDEN_MULT_EVEN_EXPR:
  case VEC_WIDEN_MULT_ODD_EXPR:
    {
      if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
          || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
   || !types_compatible_p (rhs1_type, rhs2_type)
   || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
	 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }
      return false;
    }

  case VEC_PACK_TRUNC_EXPR:
    /* ???  We currently use VEC_PACK_TRUNC_EXPR to simply concat
vector boolean types.  */
    if (VECTOR_BOOLEAN_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4169, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
 && VECTOR_BOOLEAN_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4170, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
 && types_compatible_p (rhs1_type, rhs2_type)
 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),(!maybe_ne (TYPE_VECTOR_SUBPARTS (lhs_type), 2 * TYPE_VECTOR_SUBPARTS
 (rhs1_type)))
       2 * TYPE_VECTOR_SUBPARTS (rhs1_type))(!maybe_ne (TYPE_VECTOR_SUBPARTS (lhs_type), 2 * TYPE_VECTOR_SUBPARTS
 (rhs1_type))))
return false;

    /* Fallthru.  */
  case VEC_PACK_SAT_EXPR:
  case VEC_PACK_FIX_TRUNC_EXPR:
    {
      if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
          || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
          || !((rhs_code == VEC_PACK_FIX_TRUNC_EXPR
  && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4183, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
  && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4184, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4184, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4184, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4185, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4185, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4185, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
     == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4186, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4186, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((lhs_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4186, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)))
   || !types_compatible_p (rhs1_type, rhs2_type)
   || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
	 2 * GET_MODE_SIZE (element_mode (lhs_type)))
   || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
	 TYPE_VECTOR_SUBPARTS (lhs_type)))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }

      return false;
    }

  case VEC_PACK_FLOAT_EXPR:
    if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))(((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4206, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4206, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((rhs1_type), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4206, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)
 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))(((enum tree_code) (((contains_struct_check ((lhs_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4207, __FUNCTION__))->typed.type))->base.code) == REAL_TYPE
)
 || !types_compatible_p (rhs1_type, rhs2_type)
 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
       2 * GET_MODE_SIZE (element_mode (lhs_type)))
 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
       TYPE_VECTOR_SUBPARTS (lhs_type)))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 return true;
}

    return false;

  case MULT_EXPR:
  case MULT_HIGHPART_EXPR:
  case TRUNC_DIV_EXPR:
  case CEIL_DIV_EXPR:
  case FLOOR_DIV_EXPR:
  case ROUND_DIV_EXPR:
  case TRUNC_MOD_EXPR:
  case CEIL_MOD_EXPR:
  case FLOOR_MOD_EXPR:
  case ROUND_MOD_EXPR:
  case RDIV_EXPR:
  case EXACT_DIV_EXPR:
  case BIT_IOR_EXPR:
  case BIT_XOR_EXPR:
    /* Disallow pointer and offset types for many of the binary gimple. */
    if (POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
 || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) == OFFSET_TYPE)
{
 error ("invalid types for %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 return true;
}
    /* Continue with generic binary expression handling.  */
    break;

  case MIN_EXPR:
  case MAX_EXPR:
    /* Continue with generic binary expression handling.  */
    break;

  case BIT_AND_EXPR:
    if (POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
 && TREE_CODE (rhs2)((enum tree_code) (rhs2)->base.code) == INTEGER_CST)
break;
    /* Disallow pointer and offset types for many of the binary gimple. */
    if (POINTER_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == POINTER_TYPE ||
 ((enum tree_code) (lhs_type)->base.code) == REFERENCE_TYPE
)
 || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) == OFFSET_TYPE)
{
 error ("invalid types for %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 return true;
}
    /* Continue with generic binary expression handling.  */
    break;

  case VEC_SERIES_EXPR:
    if (!useless_type_conversion_p (rhs1_type, rhs2_type))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 return true;
}
    if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
 || !useless_type_conversion_p (TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4281, __FUNCTION__))->typed.type), rhs1_type))
{
 error ("vector type expected in %qs", code_name);
 debug_generic_expr (lhs_type);
 return true;
}
    return false;

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4290, __FUNCTION__));
  }

if (!useless_type_conversion_p (lhs_type, rhs1_type)
    || !useless_type_conversion_p (lhs_type, rhs2_type))
  {
    error ("type mismatch in binary expression");
    debug_generic_stmt (lhs_type);
    debug_generic_stmt (rhs1_type);
    debug_generic_stmt (rhs2_type);
    return true;
  }

return false;
4304}

4306/* Verify a gimple assignment statement STMT with a ternary rhs.
 Returns true if anything is wrong.  */

4309static bool
4310verify_gimple_assign_ternary (gassign *stmt)
4311{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4314, __FUNCTION__))->typed.type);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4316, __FUNCTION__))->typed.type);
tree rhs2 = gimple_assign_rhs2 (stmt);
tree rhs2_type = TREE_TYPE (rhs2)((contains_struct_check ((rhs2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4318, __FUNCTION__))->typed.type);
tree rhs3 = gimple_assign_rhs3 (stmt);
tree rhs3_type = TREE_TYPE (rhs3)((contains_struct_check ((rhs3), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4320, __FUNCTION__))->typed.type);

if (!is_gimple_reg (lhs))
  {
    error ("non-register as LHS of ternary operation");
    return true;
  }

if (!is_gimple_val (rhs1)
    || !is_gimple_val (rhs2)
    || !is_gimple_val (rhs3))
  {
    error ("invalid operands in ternary operation");
    return true;
  }

const char* const code_name = get_tree_code_name (rhs_code);

/* First handle operations that involve different types.  */
switch (rhs_code)
  {
  case WIDEN_MULT_PLUS_EXPR:
  case WIDEN_MULT_MINUS_EXPR:
    if ((!INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
  && !FIXED_POINT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == FIXED_POINT_TYPE
))
 || !useless_type_conversion_p (rhs1_type, rhs2_type)
 || !useless_type_conversion_p (lhs_type, rhs3_type)
 || 2 * TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4347, __FUNCTION__))->type_common.precision) > TYPE_PRECISION (lhs_type)((tree_class_check ((lhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4347, __FUNCTION__))->type_common.precision)
 || TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4348, __FUNCTION__))->type_common.precision) != TYPE_PRECISION (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4348, __FUNCTION__))->type_common.precision))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}
    break;

  case VEC_COND_EXPR:
    if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE &&
 ((enum tree_code) (((contains_struct_check ((rhs1_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4360, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
)
 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
       TYPE_VECTOR_SUBPARTS (lhs_type)))
{
 error ("the first argument of a %qs must be of a "
 "boolean vector type of the same number of elements "
 "as the result", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
}
    /* Fallthrough.  */
  case COND_EXPR:
    if (!useless_type_conversion_p (lhs_type, rhs2_type)
 || !useless_type_conversion_p (lhs_type, rhs3_type))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}
    break;

  case VEC_PERM_EXPR:
    /* If permute is constant, then we allow for lhs and rhs
to have different vector types, provided:
(1) lhs, rhs1, rhs2 have same element type.
(2) rhs3 vector is constant and has integer element type.
(3) len(lhs) == len(rhs3) && len(rhs1) == len(rhs2).  */

    if (TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (rhs2_type)((enum tree_code) (rhs2_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (rhs3_type)((enum tree_code) (rhs3_type)->base.code) != VECTOR_TYPE)
{
 error ("vector types expected in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}

    /* If rhs3 is constant, we allow lhs, rhs1 and rhs2 to be different vector types,
as long as lhs, rhs1 and rhs2 have same element type.  */
    if (TREE_CONSTANT (rhs3)((non_type_check ((rhs3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4406, __FUNCTION__))->base.constant_flag)
 ? (!useless_type_conversion_p (TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4407, __FUNCTION__))->typed.type), TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4407, __FUNCTION__))->typed.type))
    || !useless_type_conversion_p (TREE_TYPE (lhs_type)((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4408, __FUNCTION__))->typed.type), TREE_TYPE (rhs2_type)((contains_struct_check ((rhs2_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4408, __FUNCTION__))->typed.type)))
 : (!useless_type_conversion_p (lhs_type, rhs1_type)
    || !useless_type_conversion_p (lhs_type, rhs2_type)))
{
   error ("type mismatch in %qs", code_name);
   debug_generic_expr (lhs_type);
   debug_generic_expr (rhs1_type);
   debug_generic_expr (rhs2_type);
   debug_generic_expr (rhs3_type);
   return true;
}

    /* If rhs3 is constant, relax the check len(rhs2) == len(rhs3).  */
    if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
    TYPE_VECTOR_SUBPARTS (rhs2_type))
 || (!TREE_CONSTANT(rhs3)((non_type_check ((rhs3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4423, __FUNCTION__))->base.constant_flag)
     && maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type),
	   TYPE_VECTOR_SUBPARTS (rhs3_type)))
 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type),
       TYPE_VECTOR_SUBPARTS (lhs_type)))
{
 error ("vectors with different element number found in %qs",
 code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}

    if (TREE_CODE (TREE_TYPE (rhs3_type))((enum tree_code) (((contains_struct_check ((rhs3_type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4438, __FUNCTION__))->typed.type))->base.code) != INTEGER_TYPE
 || (TREE_CODE (rhs3)((enum tree_code) (rhs3)->base.code) != VECTOR_CST
     && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE(as_a <scalar_int_mode> ((tree_class_check ((((contains_struct_check
 ((rhs3_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4441, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4441, __FUNCTION__))->type_common.mode))
		    (TREE_TYPE (rhs3_type))(as_a <scalar_int_mode> ((tree_class_check ((((contains_struct_check
 ((rhs3_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4441, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4441, __FUNCTION__))->type_common.mode)))
  != GET_MODE_BITSIZE (SCALAR_TYPE_MODE(as_a <scalar_mode> ((tree_class_check ((((contains_struct_check
 ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4443, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4443, __FUNCTION__))->type_common.mode))
		       (TREE_TYPE (rhs1_type))(as_a <scalar_mode> ((tree_class_check ((((contains_struct_check
 ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4443, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4443, __FUNCTION__))->type_common.mode))))))
{
 error ("invalid mask type in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}

    return false;

  case SAD_EXPR:
    if (!useless_type_conversion_p (rhs1_type, rhs2_type)
 || !useless_type_conversion_p (lhs_type, rhs3_type)
 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))((unsigned short) (mode_to_unit_size (((((enum tree_code) ((tree_class_check
 ((((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4458, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4458, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4458, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4458, __FUNCTION__))->typed.type))->type_common.mode)
) * (8)))
      > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type)))((unsigned short) (mode_to_unit_size (((((enum tree_code) ((tree_class_check
 ((((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4459, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4459, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (((contains_struct_check ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4459, __FUNCTION__))->typed.type)) : (((contains_struct_check
 ((lhs_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4459, __FUNCTION__))->typed.type))->type_common.mode)
) * (8))))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}

    if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (rhs2_type)((enum tree_code) (rhs2_type)->base.code) != VECTOR_TYPE
 || TREE_CODE (rhs3_type)((enum tree_code) (rhs3_type)->base.code) != VECTOR_TYPE)
{
 error ("vector types expected in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 debug_generic_expr (rhs3_type);
 return true;
}

    return false;

  case BIT_INSERT_EXPR:
    if (! useless_type_conversion_p (lhs_type, rhs1_type))
{
 error ("type mismatch in %qs", code_name);
 debug_generic_expr (lhs_type);
 debug_generic_expr (rhs1_type);
 return true;
}
    if (! ((INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
     && INTEGRAL_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs2_type)->base.code) == INTEGER_TYPE
))
    /* Vector element insert.  */
    || (VECTOR_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE)
 && types_compatible_p (TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4495, __FUNCTION__))->typed.type), rhs2_type))
    /* Aligned sub-vector insert.  */
    || (VECTOR_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE)
 && VECTOR_TYPE_P (rhs2_type)(((enum tree_code) (rhs2_type)->base.code) == VECTOR_TYPE)
 && types_compatible_p (TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4499, __FUNCTION__))->typed.type),
			TREE_TYPE (rhs2_type)((contains_struct_check ((rhs2_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4500, __FUNCTION__))->typed.type))
 && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type),
		TYPE_VECTOR_SUBPARTS (rhs2_type))
 && multiple_p (wi::to_poly_offset (rhs3),
		wi::to_poly_offset (TYPE_SIZE (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4504, __FUNCTION__))->type_common.size))))))
{
 error ("not allowed type combination in %qs", code_name);
 debug_generic_expr (rhs1_type);
 debug_generic_expr (rhs2_type);
 return true;
}
    if (! tree_fits_uhwi_p (rhs3)
 || ! types_compatible_p (bitsizetypesizetype_tab[(int) stk_bitsizetype], TREE_TYPE (rhs3)((contains_struct_check ((rhs3), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4512, __FUNCTION__))->typed.type))
 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4513, __FUNCTION__))->type_common.size)))
{
 error ("invalid position or size in %qs", code_name);
 return true;
}
    if (INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
 && !type_has_mode_precision_p (rhs1_type))
{
 error ("%qs into non-mode-precision operand", code_name);
 return true;
}
    if (INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
))
{
 unsigned HOST_WIDE_INTlong bitpos = tree_to_uhwi (rhs3);
 if (bitpos >= TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4527, __FUNCTION__))->type_common.precision)
     || (bitpos + TYPE_PRECISION (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4528, __FUNCTION__))->type_common.precision)
  > TYPE_PRECISION (rhs1_type)((tree_class_check ((rhs1_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4529, __FUNCTION__))->type_common.precision)))
   {
     error ("insertion out of range in %qs", code_name);
     return true;
   }
}
    else if (VECTOR_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE))
{
 unsigned HOST_WIDE_INTlong bitpos = tree_to_uhwi (rhs3);
 unsigned HOST_WIDE_INTlong bitsize = tree_to_uhwi (TYPE_SIZE (rhs2_type)((tree_class_check ((rhs2_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4538, __FUNCTION__))->type_common.size));
 if (bitpos % bitsize != 0)
   {
     error ("%qs not at element boundary", code_name);
     return true;
   }
}
    return false;

  case DOT_PROD_EXPR:
    {
      if (((TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) != VECTOR_TYPE
     || TREE_CODE (lhs_type)((enum tree_code) (lhs_type)->base.code) != VECTOR_TYPE)
    && ((!INTEGRAL_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (rhs1_type)->base.code) == INTEGER_TYPE
)
  && !SCALAR_FLOAT_TYPE_P (rhs1_type)(((enum tree_code) (rhs1_type)->base.code) == REAL_TYPE))
 || (!INTEGRAL_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (lhs_type)->base.code) == INTEGER_TYPE
)
     && !SCALAR_FLOAT_TYPE_P (lhs_type)(((enum tree_code) (lhs_type)->base.code) == REAL_TYPE))))
   /* rhs1_type and rhs2_type may differ in sign.  */
   || !tree_nop_conversion_p (rhs1_type, rhs2_type)
   || !useless_type_conversion_p (lhs_type, rhs3_type)
   || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type)),
	 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
        {
   error ("type mismatch in %qs", code_name);
          debug_generic_expr (lhs_type);
          debug_generic_expr (rhs1_type);
          debug_generic_expr (rhs2_type);
          return true;
        }
      return false;
    }

  case REALIGN_LOAD_EXPR:
    /* FIXME.  */
    return false;

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4575, __FUNCTION__));
  }
return false;
4578}

4580/* Verify a gimple assignment statement STMT with a single rhs.
 Returns true if anything is wrong.  */

4583static bool
4584verify_gimple_assign_single (gassign *stmt)
4585{
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
tree lhs = gimple_assign_lhs (stmt);
tree lhs_type = TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4588, __FUNCTION__))->typed.type);
tree rhs1 = gimple_assign_rhs1 (stmt);
tree rhs1_type = TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4590, __FUNCTION__))->typed.type);
bool res = false;

const char* const code_name = get_tree_code_name (rhs_code);

if (!useless_type_conversion_p (lhs_type, rhs1_type))
  {
    error ("non-trivial conversion in %qs", code_name);
    debug_generic_expr (lhs_type);
    debug_generic_expr (rhs1_type);
    return true;
  }

if (gimple_clobber_p (stmt)
    && !(DECL_P (lhs)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (lhs)->base.code))] == tcc_declaration) || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == MEM_REF))
  {
    error ("%qs LHS in clobber statement",
    get_tree_code_name (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code)));
    debug_generic_expr (lhs);
    return true;
  }

if (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == WITH_SIZE_EXPR)
  {
    error ("%qs LHS in assignment statement",
    get_tree_code_name (TREE_CODE (lhs)((enum tree_code) (lhs)->base.code)));
    debug_generic_expr (lhs);
    return true;
  }

if (handled_component_p (lhs)
    || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == MEM_REF
    || TREE_CODE (lhs)((enum tree_code) (lhs)->base.code) == TARGET_MEM_REF)
  res |= verify_types_in_gimple_reference (lhs, true);

/* Special codes we cannot handle via their class.  */
switch (rhs_code)
  {
  case ADDR_EXPR:
    {
tree op = TREE_OPERAND (rhs1, 0)(*((const_cast<tree*> (tree_operand_check ((rhs1), (0),
 "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4630, __FUNCTION__)))));
if (!is_gimple_addressable (op))
 {
   error ("invalid operand in %qs", code_name);
   return true;
 }

/* Technically there is no longer a need for matching types, but
  gimple hygiene asks for this check.  In LTO we can end up
  combining incompatible units and thus end up with addresses
  of globals that change their type to a common one.  */
if (!in_lto_pglobal_options.x_in_lto_p
   && !types_compatible_p (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4642, __FUNCTION__))->typed.type),
		    TREE_TYPE (TREE_TYPE (rhs1))((contains_struct_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4643, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4643, __FUNCTION__))->typed.type))
   && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4644, __FUNCTION__))->typed.type),
					  TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4645, __FUNCTION__))->typed.type)))
 {
   error ("type mismatch in %qs", code_name);
   debug_generic_stmt (TREE_TYPE (rhs1)((contains_struct_check ((rhs1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4648, __FUNCTION__))->typed.type));
   debug_generic_stmt (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4649, __FUNCTION__))->typed.type));
   return true;
 }

return (verify_address (rhs1, true)
|| verify_types_in_gimple_reference (op, true));
    }

  /* tcc_reference  */
  case INDIRECT_REF:
    error ("%qs in gimple IL", code_name);
    return true;

  case COMPONENT_REF:
  case BIT_FIELD_REF:
  case ARRAY_REF:
  case ARRAY_RANGE_REF:
  case VIEW_CONVERT_EXPR:
  case REALPART_EXPR:
  case IMAGPART_EXPR:
  case TARGET_MEM_REF:
  case MEM_REF:
    if (!is_gimple_reg (lhs)
 && is_gimple_reg_type (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4672, __FUNCTION__))->typed.type)))
{
 error ("invalid RHS for gimple memory store: %qs", code_name);
 debug_generic_stmt (lhs);
 debug_generic_stmt (rhs1);
 return true;
}
    return res || verify_types_in_gimple_reference (rhs1, false);

  /* tcc_constant  */
  case SSA_NAME:
  case INTEGER_CST:
  case REAL_CST:
  case FIXED_CST:
  case COMPLEX_CST:
  case VECTOR_CST:
  case STRING_CST:
    return res;

  /* tcc_declaration  */
  case CONST_DECL:
    return res;
  case VAR_DECL:
  case PARM_DECL:
    if (!is_gimple_reg (lhs)
 && !is_gimple_reg (rhs1)
 && is_gimple_reg_type (TREE_TYPE (lhs)((contains_struct_check ((lhs), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4698, __FUNCTION__))->typed.type)))
{
 error ("invalid RHS for gimple memory store: %qs", code_name);
 debug_generic_stmt (lhs);
 debug_generic_stmt (rhs1);
 return true;
}
    return res;

  case CONSTRUCTOR:
    if (TREE_CODE (rhs1_type)((enum tree_code) (rhs1_type)->base.code) == VECTOR_TYPE)
{
 unsigned int i;
 tree elt_i, elt_v, elt_t = NULL_TREE(tree) nullptr;

 if (CONSTRUCTOR_NELTS (rhs1)(vec_safe_length (((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4713, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) == 0)
   return res;
 /* For vector CONSTRUCTORs we require that either it is empty
    CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
    (then the element count must be correct to cover the whole
    outer vector and index must be NULL on all elements, or it is
    a CONSTRUCTOR of scalar elements, where we as an exception allow
    smaller number of elements (assuming zero filling) and
    consecutive indexes as compared to NULL indexes (such
    CONSTRUCTORs can appear in the IL from FEs).  */
 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1), i, elt_i, elt_v)for (i = 0; (i >= vec_safe_length (((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4723, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
 ? false : (((void) (elt_v = (*((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4723, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
i].value)), (elt_i = (*((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4723, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))[
i].index), true); (i)++)
   {
     if (elt_t == NULL_TREE(tree) nullptr)
{
  elt_t = TREE_TYPE (elt_v)((contains_struct_check ((elt_v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4727, __FUNCTION__))->typed.type);
  if (TREE_CODE (elt_t)((enum tree_code) (elt_t)->base.code) == VECTOR_TYPE)
    {
      tree elt_t = TREE_TYPE (elt_v)((contains_struct_check ((elt_v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4730, __FUNCTION__))->typed.type);
      if (!useless_type_conversion_p (TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4731, __FUNCTION__))->typed.type),
				      TREE_TYPE (elt_t)((contains_struct_check ((elt_t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4732, __FUNCTION__))->typed.type)))
	{
	  error ("incorrect type of vector %qs elements",
		 code_name);
	  debug_generic_stmt (rhs1);
	  return true;
	}
      else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1)(vec_safe_length (((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4739, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
			 * TYPE_VECTOR_SUBPARTS (elt_t),
			 TYPE_VECTOR_SUBPARTS (rhs1_type)))
	{
	  error ("incorrect number of vector %qs elements",
		 code_name);
	  debug_generic_stmt (rhs1);
	  return true;
	}
    }
  else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type)((contains_struct_check ((rhs1_type), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4749, __FUNCTION__))->typed.type),
				       elt_t))
    {
      error ("incorrect type of vector %qs elements",
	     code_name);
      debug_generic_stmt (rhs1);
      return true;
    }
  else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1),maybe_lt (TYPE_VECTOR_SUBPARTS (rhs1_type), (vec_safe_length (
((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4757, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
)
		     TYPE_VECTOR_SUBPARTS (rhs1_type))maybe_lt (TYPE_VECTOR_SUBPARTS (rhs1_type), (vec_safe_length (
((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4757, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts)))
))
    {
      error ("incorrect number of vector %qs elements",
	     code_name);
      debug_generic_stmt (rhs1);
      return true;
    }
}
     else if (!useless_type_conversion_p (elt_t, TREE_TYPE (elt_v)((contains_struct_check ((elt_v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4766, __FUNCTION__))->typed.type)))
{
  error ("incorrect type of vector CONSTRUCTOR elements");
  debug_generic_stmt (rhs1);
  return true;
}
     if (elt_i != NULL_TREE(tree) nullptr
  && (TREE_CODE (elt_t)((enum tree_code) (elt_t)->base.code) == VECTOR_TYPE
      || TREE_CODE (elt_i)((enum tree_code) (elt_i)->base.code) != INTEGER_CST
      || compare_tree_int (elt_i, i) != 0))
{
  error ("vector %qs with non-NULL element index",
	 code_name);
  debug_generic_stmt (rhs1);
  return true;
}
     if (!is_gimple_val (elt_v))
{
  error ("vector %qs element is not a GIMPLE value",
	 code_name);
  debug_generic_stmt (rhs1);
  return true;
}
   }
}
    else if (CONSTRUCTOR_NELTS (rhs1)(vec_safe_length (((tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4791, __FUNCTION__, (CONSTRUCTOR)))->constructor.elts))) != 0)
{
 error ("non-vector %qs with elements", code_name);
 debug_generic_stmt (rhs1);
 return true;
}
    return res;

  case WITH_SIZE_EXPR:
    error ("%qs RHS in assignment statement",
    get_tree_code_name (rhs_code));
    debug_generic_expr (rhs1);
    return true;

  case OBJ_TYPE_REF:
    /* FIXME.  */
    return res;

  default:;
  }

return res;
4813}

4815/* Verify the contents of a GIMPLE_ASSIGN STMT.  Returns true when there
 is a problem, otherwise false.  */

4818static bool
4819verify_gimple_assign (gassign *stmt)
4820{
switch (gimple_assign_rhs_class (stmt))
  {
  case GIMPLE_SINGLE_RHS:
    return verify_gimple_assign_single (stmt);

  case GIMPLE_UNARY_RHS:
    return verify_gimple_assign_unary (stmt);

  case GIMPLE_BINARY_RHS:
    return verify_gimple_assign_binary (stmt);

  case GIMPLE_TERNARY_RHS:
    return verify_gimple_assign_ternary (stmt);

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4836, __FUNCTION__));
  }
4838}

4840/* Verify the contents of a GIMPLE_RETURN STMT.  Returns true when there
 is a problem, otherwise false.  */

4843static bool
4844verify_gimple_return (greturn *stmt)
4845{
tree op = gimple_return_retval (stmt);
tree restype = TREE_TYPE (TREE_TYPE (cfun->decl))((contains_struct_check ((((contains_struct_check (((cfun + 0
)->decl), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4847, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4847, __FUNCTION__))->typed.type);

/* We cannot test for present return values as we do not fix up missing
   return values from the original source.  */
if (op == NULLnullptr)
  return false;

if (!is_gimple_val (op)
    && TREE_CODE (op)((enum tree_code) (op)->base.code) != RESULT_DECL)
  {
    error ("invalid operand in return statement");
    debug_generic_stmt (op);
    return true;
  }

if ((TREE_CODE (op)((enum tree_code) (op)->base.code) == RESULT_DECL
     && DECL_BY_REFERENCE (op)((tree_check3 ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4863, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag))
    || (TREE_CODE (op)((enum tree_code) (op)->base.code) == SSA_NAME
 && SSA_NAME_VAR (op)((tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4865, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((op)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (op)->ssa_name
.var)
 && TREE_CODE (SSA_NAME_VAR (op))((enum tree_code) (((tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4866, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((op)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (op)->ssa_name
.var))->base.code) == RESULT_DECL
 && DECL_BY_REFERENCE (SSA_NAME_VAR (op))((tree_check3 ((((tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4867, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((op)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (op)->ssa_name
.var)), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4867, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
)->decl_common.decl_by_reference_flag)))
  op = TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4868, __FUNCTION__))->typed.type);

if (!useless_type_conversion_p (restype, TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4870, __FUNCTION__))->typed.type)))
  {
    error ("invalid conversion in return statement");
    debug_generic_stmt (restype);
    debug_generic_stmt (TREE_TYPE (op)((contains_struct_check ((op), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4874, __FUNCTION__))->typed.type));
    return true;
  }

return false;
4879}


4882/* Verify the contents of a GIMPLE_GOTO STMT.  Returns true when there
 is a problem, otherwise false.  */

4885static bool
4886verify_gimple_goto (ggoto *stmt)
4887{
tree dest = gimple_goto_dest (stmt);

/* ???  We have two canonical forms of direct goto destinations, a
   bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL.  */
if (TREE_CODE (dest)((enum tree_code) (dest)->base.code) != LABEL_DECL
    && (!is_gimple_val (dest)
 || !POINTER_TYPE_P (TREE_TYPE (dest))(((enum tree_code) (((contains_struct_check ((dest), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4894, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((dest), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4894, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)))
  {
    error ("goto destination is neither a label nor a pointer");
    return true;
  }

return false;
4901}

4903/* Verify the contents of a GIMPLE_SWITCH STMT.  Returns true when there
 is a problem, otherwise false.  */

4906static bool
4907verify_gimple_switch (gswitch *stmt)
4908{
unsigned int i, n;
tree elt, prev_upper_bound = NULL_TREE(tree) nullptr;
tree index_type, elt_type = NULL_TREE(tree) nullptr;

if (!is_gimple_val (gimple_switch_index (stmt)))
  {
    error ("invalid operand to switch statement");
    debug_generic_stmt (gimple_switch_index (stmt));
    return true;
  }

index_type = TREE_TYPE (gimple_switch_index (stmt))((contains_struct_check ((gimple_switch_index (stmt)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4920, __FUNCTION__))->typed.type);
if (! INTEGRAL_TYPE_P (index_type)(((enum tree_code) (index_type)->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (index_type)->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (index_type)->base.code) == INTEGER_TYPE
))
  {
    error ("non-integral type switch statement");
    debug_generic_expr (index_type);
    return true;
  }

elt = gimple_switch_label (stmt, 0);
if (CASE_LOW (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4929, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4929, __FUNCTION__))))) != NULL_TREE(tree) nullptr
    || CASE_HIGH (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4930, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4930, __FUNCTION__))))) != NULL_TREE(tree) nullptr
    || CASE_CHAIN (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4931, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4931, __FUNCTION__))))) != NULL_TREE(tree) nullptr)
  {
    error ("invalid default case label in switch statement");
    debug_generic_expr (elt);
    return true;
  }

n = gimple_switch_num_labels (stmt);
for (i = 1; i < n; i++)
  {
    elt = gimple_switch_label (stmt, i);

    if (CASE_CHAIN (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4943, __FUNCTION__, (CASE_LABEL_EXPR)))), (3), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4943, __FUNCTION__))))))
{
 error ("invalid %<CASE_CHAIN%>");
 debug_generic_expr (elt);
 return true;
}
    if (! CASE_LOW (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4949, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4949, __FUNCTION__))))))
{
 error ("invalid case label in switch statement");
 debug_generic_expr (elt);
 return true;
}
    if (CASE_HIGH (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4955, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4955, __FUNCTION__)))))
 && ! tree_int_cst_lt (CASE_LOW (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4956, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4956, __FUNCTION__))))), CASE_HIGH (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4956, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4956, __FUNCTION__)))))))
{
 error ("invalid case range in switch statement");
 debug_generic_expr (elt);
 return true;
}

    if (! elt_type)
{
 elt_type = TREE_TYPE (CASE_LOW (elt))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4965, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4965, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4965, __FUNCTION__))->typed.type);
 if (TYPE_PRECISION (index_type)((tree_class_check ((index_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4966, __FUNCTION__))->type_common.precision) < TYPE_PRECISION (elt_type)((tree_class_check ((elt_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4966, __FUNCTION__))->type_common.precision))
   {
     error ("type precision mismatch in switch statement");
     return true;
   }
}
    if (TREE_TYPE (CASE_LOW (elt))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4972, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4972, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4972, __FUNCTION__))->typed.type) != elt_type
        || (CASE_HIGH (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4973, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4973, __FUNCTION__))))) && TREE_TYPE (CASE_HIGH (elt))((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4973, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4973, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4973, __FUNCTION__))->typed.type) != elt_type))
{
 error ("type mismatch for case label in switch statement");
 debug_generic_expr (elt);
 return true;
}

    if (prev_upper_bound)
{
 if (! tree_int_cst_lt (prev_upper_bound, CASE_LOW (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4982, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4982, __FUNCTION__)))))))
   {
     error ("case labels not sorted in switch statement");
     return true;
   }
}

    prev_upper_bound = CASE_HIGH (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4989, __FUNCTION__, (CASE_LABEL_EXPR)))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4989, __FUNCTION__)))));
    if (! prev_upper_bound)
prev_upper_bound = CASE_LOW (elt)(*((const_cast<tree*> (tree_operand_check (((tree_check
 ((elt), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4991, __FUNCTION__, (CASE_LABEL_EXPR)))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 4991, __FUNCTION__)))));
  }

return false;
4995}

4997/* Verify a gimple debug statement STMT.
 Returns true if anything is wrong.  */

5000static bool
5001verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED__attribute__ ((__unused__)))
5002{
/* There isn't much that could be wrong in a gimple debug stmt.  A
   gimple debug bind stmt, for example, maps a tree, that's usually
   a VAR_DECL or a PARM_DECL, but that could also be some scalarized
   component or member of an aggregate type, to another tree, that
   can be an arbitrary expression.  These stmts expand into debug
   insns, and are converted to debug notes by var-tracking.cc.  */
return false;
5010}

5012/* Verify a gimple label statement STMT.
 Returns true if anything is wrong.  */

5015static bool
5016verify_gimple_label (glabel *stmt)
5017{
tree decl = gimple_label_label (stmt);
int uid;
bool err = false;

if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) != LABEL_DECL)
  return true;
if (!DECL_NONLOCAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5024, __FUNCTION__))->decl_common.nonlocal_flag) && !FORCED_LABEL (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5024, __FUNCTION__, (LABEL_DECL)))->base.side_effects_flag
)
    && DECL_CONTEXT (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5025, __FUNCTION__))->decl_minimal.context) != current_function_decl)
  {
    error ("label context is not the current function declaration");
    err |= true;
  }

uid = LABEL_DECL_UID (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5031, __FUNCTION__, (LABEL_DECL)))->label_decl.label_decl_uid
);
if (cfun(cfun + 0)->cfg
    && (uid == -1
 || (*label_to_block_map_for_fn (cfun)(((cfun + 0))->cfg->x_label_to_block_map))[uid] != gimple_bb (stmt)))
  {
    error ("incorrect entry in %<label_to_block_map%>");
    err |= true;
  }

uid = EH_LANDING_PAD_NR (decl)((tree_check ((decl), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5040, __FUNCTION__, (LABEL_DECL)))->label_decl.eh_landing_pad_nr
);
if (uid)
  {
    eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
    if (decl != lp->post_landing_pad)
{
 error ("incorrect setting of landing pad number");
 err |= true;
}
  }

return err;
5052}

5054/* Verify a gimple cond statement STMT.
 Returns true if anything is wrong.  */

5057static bool
5058verify_gimple_cond (gcond *stmt)
5059{
if (TREE_CODE_CLASS (gimple_cond_code (stmt))tree_code_type_tmpl <0>::tree_code_type[(int) (gimple_cond_code
 (stmt))] != tcc_comparison)
  {
    error ("invalid comparison code in gimple cond");
    return true;
  }
if (!(!gimple_cond_true_label (stmt)
|| TREE_CODE (gimple_cond_true_label (stmt))((enum tree_code) (gimple_cond_true_label (stmt))->base.code
) == LABEL_DECL)
    || !(!gimple_cond_false_label (stmt)
  || TREE_CODE (gimple_cond_false_label (stmt))((enum tree_code) (gimple_cond_false_label (stmt))->base.code
) == LABEL_DECL))
  {
    error ("invalid labels in gimple cond");
    return true;
  }

return verify_gimple_comparison (boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE],
		   gimple_cond_lhs (stmt),
		   gimple_cond_rhs (stmt),
		   gimple_cond_code (stmt));
5078}

5080/* Verify the GIMPLE statement STMT.  Returns true if there is an
 error, otherwise false.  */

5083static bool
5084verify_gimple_stmt (gimple *stmt)
5085{
switch (gimple_code (stmt))
  {
  case GIMPLE_ASSIGN:
    return verify_gimple_assign (as_a <gassign *> (stmt));

  case GIMPLE_LABEL:
    return verify_gimple_label (as_a <glabel *> (stmt));

  case GIMPLE_CALL:
    return verify_gimple_call (as_a <gcall *> (stmt));

  case GIMPLE_COND:
    return verify_gimple_cond (as_a <gcond *> (stmt));

  case GIMPLE_GOTO:
    return verify_gimple_goto (as_a <ggoto *> (stmt));

  case GIMPLE_SWITCH:
    return verify_gimple_switch (as_a <gswitch *> (stmt));

  case GIMPLE_RETURN:
    return verify_gimple_return (as_a <greturn *> (stmt));

  case GIMPLE_ASM:
    return false;

  case GIMPLE_TRANSACTION:
    return verify_gimple_transaction (as_a <gtransaction *> (stmt));

  /* Tuples that do not have tree operands.  */
  case GIMPLE_NOP:
  case GIMPLE_PREDICT:
  case GIMPLE_RESX:
  case GIMPLE_EH_DISPATCH:
  case GIMPLE_EH_MUST_NOT_THROW:
    return false;

  CASE_GIMPLE_OMPcase GIMPLE_OMP_PARALLEL: case GIMPLE_OMP_TASK: case GIMPLE_OMP_FOR
: case GIMPLE_OMP_SECTIONS: case GIMPLE_OMP_SECTIONS_SWITCH: case
 GIMPLE_OMP_SINGLE: case GIMPLE_OMP_TARGET: case GIMPLE_OMP_TEAMS
: case GIMPLE_OMP_SCOPE: case GIMPLE_OMP_SECTION: case GIMPLE_OMP_MASTER
: case GIMPLE_OMP_MASKED: case GIMPLE_OMP_TASKGROUP: case GIMPLE_OMP_ORDERED
: case GIMPLE_OMP_CRITICAL: case GIMPLE_OMP_SCAN: case GIMPLE_OMP_RETURN
: case GIMPLE_OMP_ATOMIC_LOAD: case GIMPLE_OMP_ATOMIC_STORE: case
 GIMPLE_OMP_CONTINUE:
    /* OpenMP directives are validated by the FE and never operated
on by the optimizers.  Furthermore, GIMPLE_OMP_FOR may contain
non-gimple expressions when the main index variable has had
its address taken.  This does not affect the loop itself
because the header of an GIMPLE_OMP_FOR is merely used to determine
how to setup the parallel iteration.  */
    return false;

  case GIMPLE_ASSUME:
    return false;

  case GIMPLE_DEBUG:
    return verify_gimple_debug (stmt);

  default:
    gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5139, __FUNCTION__));
  }
5141}

5143/* Verify the contents of a GIMPLE_PHI.  Returns true if there is a problem,
 and false otherwise.  */

5146static bool
5147verify_gimple_phi (gphi *phi)
5148{
bool err = false;
unsigned i;
tree phi_result = gimple_phi_result (phi);
bool virtual_p;

if (!phi_result)
  {
    error ("invalid %<PHI%> result");
    return true;
  }

virtual_p = virtual_operand_p (phi_result);
if (TREE_CODE (phi_result)((enum tree_code) (phi_result)->base.code) != SSA_NAME
    || (virtual_p
 && SSA_NAME_VAR (phi_result)((tree_check ((phi_result), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5163, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((phi_result)->ssa_name.var)
->base.code) == IDENTIFIER_NODE ? (tree) nullptr : (phi_result
)->ssa_name.var) != gimple_vop (cfun(cfun + 0))))
  {
    error ("invalid %<PHI%> result");
    err = true;
  }

for (i = 0; i < gimple_phi_num_args (phi); i++)
  {
    tree t = gimple_phi_arg_def (phi, i);

    if (!t)
{
 error ("missing %<PHI%> def");
 err |= true;
 continue;
}
    /* Addressable variables do have SSA_NAMEs but they
are not considered gimple values.  */
    else if ((TREE_CODE (t)((enum tree_code) (t)->base.code) == SSA_NAME
&& virtual_p != virtual_operand_p (t))
      || (virtual_p
   && (TREE_CODE (t)((enum tree_code) (t)->base.code) != SSA_NAME
       || SSA_NAME_VAR (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5185, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
 nullptr || ((enum tree_code) ((t)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (t)->ssa_name
.var) != gimple_vop (cfun(cfun + 0))))
      || (!virtual_p
   && !is_gimple_val (t)))
{
 error ("invalid %<PHI%> argument");
 debug_generic_expr (t);
 err |= true;
}
5193#ifdef ENABLE_TYPES_CHECKING1
    if (!useless_type_conversion_p (TREE_TYPE (phi_result)((contains_struct_check ((phi_result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5194, __FUNCTION__))->typed.type), TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5194, __FUNCTION__))->typed.type)))
{
 error ("incompatible types in %<PHI%> argument %u", i);
 debug_generic_stmt (TREE_TYPE (phi_result)((contains_struct_check ((phi_result), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5197, __FUNCTION__))->typed.type));
 debug_generic_stmt (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5198, __FUNCTION__))->typed.type));
 err |= true;
}
5201#endif
  }

return err;
5205}

5207/* Verify the GIMPLE statements inside the sequence STMTS.  */

5209static bool
5210verify_gimple_in_seq_2 (gimple_seq stmts)
5211{
gimple_stmt_iterator ittr;
bool err = false;

for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
  {
    gimple *stmt = gsi_stmt (ittr);

    switch (gimple_code (stmt))
      {
case GIMPLE_BIND:
 err |= verify_gimple_in_seq_2 (
                 gimple_bind_body (as_a <gbind *> (stmt)));
 break;

case GIMPLE_TRY:
 err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
 err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
 break;

case GIMPLE_EH_FILTER:
 err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
 break;

case GIMPLE_EH_ELSE:
 {
   geh_else *eh_else = as_a <geh_else *> (stmt);
   err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else));
   err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else));
 }
 break;

case GIMPLE_CATCH:
 err |= verify_gimple_in_seq_2 (gimple_catch_handler (
			   as_a <gcatch *> (stmt)));
 break;

case GIMPLE_ASSUME:
 err |= verify_gimple_in_seq_2 (gimple_assume_body (stmt));
 break;

case GIMPLE_TRANSACTION:
 err |= verify_gimple_transaction (as_a <gtransaction *> (stmt));
 break;

default:
 {
   bool err2 = verify_gimple_stmt (stmt);
   if (err2)
     debug_gimple_stmt (stmt);
   err |= err2;
 }
}
  }

return err;
5267}

5269/* Verify the contents of a GIMPLE_TRANSACTION.  Returns true if there
 is a problem, otherwise false.  */

5272static bool
5273verify_gimple_transaction (gtransaction *stmt)
5274{
tree lab;

lab = gimple_transaction_label_norm (stmt);
if (lab != NULLnullptr && TREE_CODE (lab)((enum tree_code) (lab)->base.code) != LABEL_DECL)
  return true;
lab = gimple_transaction_label_uninst (stmt);
if (lab != NULLnullptr && TREE_CODE (lab)((enum tree_code) (lab)->base.code) != LABEL_DECL)
  return true;
lab = gimple_transaction_label_over (stmt);
if (lab != NULLnullptr && TREE_CODE (lab)((enum tree_code) (lab)->base.code) != LABEL_DECL)
  return true;

return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
5288}


5291/* Verify the GIMPLE statements inside the statement list STMTS.  */

5293DEBUG_FUNCTION__attribute__ ((__used__)) bool
5294verify_gimple_in_seq (gimple_seq stmts, bool ice)
5295{
timevar_push (TV_TREE_STMT_VERIFY);
bool res = verify_gimple_in_seq_2 (stmts);
if (res && ice)
  internal_error ("%<verify_gimple%> failed");
timevar_pop (TV_TREE_STMT_VERIFY);
return res;
5302}

5304/* Return true when the T can be shared.  */

5306static bool
5307tree_node_can_be_shared (tree t)
5308{
if (IS_TYPE_OR_DECL_P (t)((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) (t)->base.code))] == tcc_type) || (tree_code_type_tmpl
 <0>::tree_code_type[(int) (((enum tree_code) (t)->base
.code))] == tcc_declaration))
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == SSA_NAME
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == IDENTIFIER_NODE
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == CASE_LABEL_EXPR
    || is_gimple_min_invariant (t))
  return true;

if (t == error_mark_nodeglobal_trees[TI_ERROR_MARK])
  return true;

return false;
5320}

5322/* Called via walk_tree.  Verify tree sharing.  */

5324static tree
5325verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
5326{
hash_set<void *> *visited = (hash_set<void *> *) data;

if (tree_node_can_be_shared (*tp))
  {
    *walk_subtrees = false;
    return NULLnullptr;
  }

if (visited->add (*tp))
  return *tp;

return NULLnullptr;
5339}

5341/* Called via walk_gimple_stmt.  Verify tree sharing.  */

5343static tree
5344verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
5345{
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
5348}

5350static bool eh_error_found;
5351bool
5352verify_eh_throw_stmt_node (gimple *const &stmt, const int &,
	   hash_set<gimple *> *visited)
5354{
if (!visited->contains (stmt))
  {
    error ("dead statement in EH table");
    debug_gimple_stmt (stmt);
    eh_error_found = true;
  }
return true;
5362}

5364/* Verify if the location LOCs block is in BLOCKS.  */

5366static bool
5367verify_location (hash_set<tree> *blocks, location_t loc)
5368{
tree block = LOCATION_BLOCK (loc)((tree) ((IS_ADHOC_LOC (loc)) ? get_data_from_adhoc_loc (line_table
, (loc)) : nullptr));
if (block != NULL_TREE(tree) nullptr
    && !blocks->contains (block))
  {
    error ("location references block not in block tree");
    return true;
  }
if (block != NULL_TREE(tree) nullptr)
  return verify_location (blocks, BLOCK_SOURCE_LOCATION (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5377, __FUNCTION__, (BLOCK)))->block.locus));
return false;
5379}

5381/* Called via walk_tree.  Verify that expressions have no blocks.  */

5383static tree
5384verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
5385{
if (!EXPR_P (*tp)((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) (*tp)->base.code))]) >= tcc_reference &&
 (tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) (*tp)->base.code))]) <= tcc_expression))
  {
    *walk_subtrees = false;
    return NULLnullptr;
  }

location_t loc = EXPR_LOCATION (*tp)((((*tp)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((*tp))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((*tp))->base.code))]) <= tcc_expression
)) ? (*tp)->exp.locus : ((location_t) 0));
if (LOCATION_BLOCK (loc)((tree) ((IS_ADHOC_LOC (loc)) ? get_data_from_adhoc_loc (line_table
, (loc)) : nullptr)) != NULLnullptr)
  return *tp;

return NULLnullptr;
5397}

5399/* Called via walk_tree.  Verify locations of expressions.  */

5401static tree
5402verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
5403{
hash_set<tree> *blocks = (hash_set<tree> *) data;
tree t = *tp;

/* ???  This doesn't really belong here but there's no good place to
   stick this remainder of old verify_expr.  */
/* ???  This barfs on debug stmts which contain binds to vars with
   different function context.  */
5411#if 0
if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL
    || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL)
  {
    tree context = decl_function_context (t);
    if (context != cfun(cfun + 0)->decl
 && !SCOPE_FILE_SCOPE_P (context)(! (context) || ((enum tree_code) (context)->base.code) ==
 TRANSLATION_UNIT_DECL)
 && !TREE_STATIC (t)((t)->base.static_flag)
 && !DECL_EXTERNAL (t)((contains_struct_check ((t), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5420, __FUNCTION__))->decl_common.decl_flag_1))
{
 error ("local declaration from a different function");
 return t;
}
  }
5426#endif

if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && DECL_HAS_DEBUG_EXPR_P (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5428, __FUNCTION__, (VAR_DECL)))->decl_common.debug_expr_is_from
))
  {
    tree x = DECL_DEBUG_EXPR (t)(decl_debug_expr_lookup ((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5430, __FUNCTION__, (VAR_DECL)))));
    tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL)walk_tree_1 (&x, verify_expr_no_block, nullptr, nullptr, nullptr
);
    if (addr)
return addr;
  }
if ((VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL)
     || TREE_CODE (t)((enum tree_code) (t)->base.code) == PARM_DECL
     || TREE_CODE (t)((enum tree_code) (t)->base.code) == RESULT_DECL)
    && DECL_HAS_VALUE_EXPR_P (t)((tree_check3 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5438, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2))
  {
    tree x = DECL_VALUE_EXPR (t)(decl_value_expr_lookup ((contains_struct_check ((t), (TS_DECL_WRTL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5440, __FUNCTION__))));
    tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL)walk_tree_1 (&x, verify_expr_no_block, nullptr, nullptr, nullptr
);
    if (addr)
return addr;
  }

if (!EXPR_P (t)((tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) (t)->base.code))]) >= tcc_reference &&
 (tree_code_type_tmpl <0>::tree_code_type[(int) (((enum
 tree_code) (t)->base.code))]) <= tcc_expression))
  {
    *walk_subtrees = false;
    return NULLnullptr;
  }

location_t loc = EXPR_LOCATION (t)((((t)) && ((tree_code_type_tmpl <0>::tree_code_type
[(int) (((enum tree_code) ((t))->base.code))]) >= tcc_reference
 && (tree_code_type_tmpl <0>::tree_code_type[(int
) (((enum tree_code) ((t))->base.code))]) <= tcc_expression
)) ? (t)->exp.locus : ((location_t) 0));
if (verify_location (blocks, loc))
  return t;

return NULLnullptr;
5457}

5459/* Called via walk_gimple_op.  Verify locations of expressions.  */

5461static tree
5462verify_expr_location (tree *tp, int *walk_subtrees, void *data)
5463{
struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
return verify_expr_location_1 (tp, walk_subtrees, wi->info);
5466}

5468/* Insert all subblocks of BLOCK into BLOCKS and recurse.  */

5470static void
5471collect_subblocks (hash_set<tree> *blocks, tree block)
5472{
tree t;
for (t = BLOCK_SUBBLOCKS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5474, __FUNCTION__, (BLOCK)))->block.subblocks); t; t = BLOCK_CHAIN (t)((tree_check ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5474, __FUNCTION__, (BLOCK)))->block.chain))
  {
    blocks->add (t);
    collect_subblocks (blocks, t);
  }
5479}

5481/* Disable warnings about missing quoting in GCC diagnostics for
 the verification errors.  Their format strings don't follow
 GCC diagnostic conventions and trigger an ICE in the end.  */
5484#if __GNUC__4 >= 10
5485#  pragma GCC diagnostic push
5486#  pragma GCC diagnostic ignored "-Wformat-diag"
5487#endif

5489/* Verify the GIMPLE statements in the CFG of FN.  */

5491DEBUG_FUNCTION__attribute__ ((__used__)) bool
5492verify_gimple_in_cfg (struct function *fn, bool verify_nothrow, bool ice)
5493{
basic_block bb;
bool err = false;

timevar_push (TV_TREE_STMT_VERIFY);
hash_set<void *> visited;
hash_set<gimple *> visited_throwing_stmts;

/* Collect all BLOCKs referenced by the BLOCK tree of FN.  */
hash_set<tree> blocks;
if (DECL_INITIAL (fn->decl)((contains_struct_check ((fn->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5503, __FUNCTION__))->decl_common.initial))
  {
    blocks.add (DECL_INITIAL (fn->decl)((contains_struct_check ((fn->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5505, __FUNCTION__))->decl_common.initial));
    collect_subblocks (&blocks, DECL_INITIAL (fn->decl)((contains_struct_check ((fn->decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-cfg.cc"
, 5506, __FUNCTION__))->decl_common.initial));
  }

FOR_EACH_BB_FN (bb, fn)for (bb = (fn)->cfg->x_entry_block_ptr->next_bb; bb !=
 (fn)->cfg->x_exit_block_ptr; bb = bb->next_bb)
  {
    gimple_stmt_iterator gsi;
    edge_iterator ei;
    edge e;

    for (gphi_iterator gpi = gsi_start_phis (bb);
  !gsi_end_p (gpi);
  gsi_next (&gpi))
{
 gphi *phi = gpi.phi ();
 bool err2 = false;
 unsigned i;

 if (gimple_bb (phi) != bb)
   {
     error ("gimple_bb (phi) is set to a wrong basic block");
     err2 = true;
   }

 err2 |= verify_gimple_phi (phi);

 /* Only PHI arguments have locations.  */
 if (gimple_location (phi) != UNKNOWN_LOCATION((location_t) 0))
   {
     error ("PHI node with location");
     err2 = true;
   }

 for (i = 0; i < gimple_phi_num_args (phi); i++)
   {
     tree arg = gimple_phi_arg_def (phi, i);
     tree addr = walk_tree (&arg, verify_node_sharing_1,walk_tree_1 (&arg, verify_node_sharing_1, &visited, nullptr
, nullptr)
		     &visited, NULL)walk_tree_1 (&arg, verify_node_sharing_1, &visited, nullptr
, nullptr);
     if (addr)
{
  error ("incorrect sharing of tree nodes");
  debug_generic_expr (addr);
  err2 |= true;
}
     location_t loc = gimple_phi_arg_location (phi, i);
     if (virtual_operand_p (gimple_phi_result (phi))
  && loc != UNKNOWN_LOCATION((location_t) 0))
{
  error ("virtual PHI with argument locations");
  err2 = true;
}
     addr = walk_tree (&arg, verify_expr_location_1, &blocks, NULL)walk_tree_1 (&arg, verify_expr_location_1, &blocks, nullptr
, nullptr);
     if (addr)
{
  debug_generic_expr (addr);
  err2 = true;
}
     err2 |= verify_location (&blocks, loc);
   }

 if (err2)
   debug_gimple_stmt (phi);
 err |= err2;
}

    for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
 gimple *stmt = gsi_stmt (gsi);
 bool err2 = false;
 struct walk_stmt_info wi;
 tree addr;
557