/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc

Bug Summary

File:	build/gcc/omp-expand.cc
Warning:	line 261, column 7 Called C++ object pointer is null
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 omp-expand.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-vMB3Xx.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc
/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc

→
1/* Expansion pass for OMP directives.  Outlines regions of certain OMP
 directives to separate functions, converts others into explicit calls to the
 runtime library (libgomp) and so forth

5Copyright (C) 2005-2023 Free Software Foundation, Inc.

7This file is part of GCC.

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

14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17for more details.

19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING3.  If not see
21<http://www.gnu.org/licenses/>.  */

23#include "config.h"
24#include "system.h"
25#include "coretypes.h"
26#include "memmodel.h"
27#include "backend.h"
28#include "target.h"
29#include "rtl.h"
30#include "tree.h"
31#include "gimple.h"
32#include "cfghooks.h"
33#include "tree-pass.h"
34#include "ssa.h"
35#include "optabs.h"
36#include "cgraph.h"
37#include "pretty-print.h"
38#include "diagnostic-core.h"
39#include "fold-const.h"
40#include "stor-layout.h"
41#include "cfganal.h"
42#include "internal-fn.h"
43#include "gimplify.h"
44#include "gimple-iterator.h"
45#include "gimplify-me.h"
46#include "gimple-walk.h"
47#include "tree-cfg.h"
48#include "tree-into-ssa.h"
49#include "tree-ssa.h"
50#include "splay-tree.h"
51#include "cfgloop.h"
52#include "omp-general.h"
53#include "omp-offload.h"
54#include "tree-cfgcleanup.h"
55#include "alloc-pool.h"
56#include "symbol-summary.h"
57#include "gomp-constants.h"
58#include "gimple-pretty-print.h"
59#include "stringpool.h"
60#include "attribs.h"
61#include "tree-eh.h"
62#include "opts.h"

64/* OMP region information.  Every parallel and workshare
 directive is enclosed between two markers, the OMP_* directive
 and a corresponding GIMPLE_OMP_RETURN statement.  */

68struct omp_region
69{
/* The enclosing region.  */
struct omp_region *outer;

/* First child region.  */
struct omp_region *inner;

/* Next peer region.  */
struct omp_region *next;

/* Block containing the omp directive as its last stmt.  */
basic_block entry;

/* Block containing the GIMPLE_OMP_RETURN as its last stmt.  */
basic_block exit;

/* Block containing the GIMPLE_OMP_CONTINUE as its last stmt.  */
basic_block cont;

/* If this is a combined parallel+workshare region, this is a list
   of additional arguments needed by the combined parallel+workshare
   library call.  */
vec<tree, va_gc> *ws_args;

/* The code for the omp directive of this region.  */
enum gimple_code type;

/* Schedule kind, only used for GIMPLE_OMP_FOR type regions.  */
enum omp_clause_schedule_kind sched_kind;

/* Schedule modifiers.  */
unsigned char sched_modifiers;

/* True if this is a combined parallel+workshare region.  */
bool is_combined_parallel;

/* Copy of fd.lastprivate_conditional != 0.  */
bool has_lastprivate_conditional;

/* The ordered stmt if type is GIMPLE_OMP_ORDERED and it has
   a depend clause.  */
gomp_ordered *ord_stmt;
111};

113static struct omp_region *root_omp_region;
114static bool omp_any_child_fn_dumped;

116static void expand_omp_build_assign (gimple_stmt_iterator *, tree, tree,
		     bool = false);
118static gphi *find_phi_with_arg_on_edge (tree, edge);
119static void expand_omp (struct omp_region *region);

121/* Return true if REGION is a combined parallel+workshare region.  */

123static inline bool
124is_combined_parallel (struct omp_region *region)
125{
return region->is_combined_parallel;
127}

129/* Given two blocks PAR_ENTRY_BB and WS_ENTRY_BB such that WS_ENTRY_BB
 is the immediate dominator of PAR_ENTRY_BB, return true if there
 are no data dependencies that would prevent expanding the parallel
 directive at PAR_ENTRY_BB as a combined parallel+workshare region.

 When expanding a combined parallel+workshare region, the call to
 the child function may need additional arguments in the case of
 GIMPLE_OMP_FOR regions.  In some cases, these arguments are
 computed out of variables passed in from the parent to the child
 via 'struct .omp_data_s'.  For instance:

#pragma omp parallel for schedule (guided, i * 4)
for (j ...)

 Is lowered into:

# BLOCK 2 (PAR_ENTRY_BB)
.omp_data_o.i = i;
#pragma omp parallel [child fn: bar.omp_fn.0 ( ..., D.1598)

# BLOCK 3 (WS_ENTRY_BB)
.omp_data_i = &.omp_data_o;
D.1667 = .omp_data_i->i;
D.1598 = D.1667 * 4;
#pragma omp for schedule (guided, D.1598)

 When we outline the parallel region, the call to the child function
 'bar.omp_fn.0' will need the value D.1598 in its argument list, but
 that value is computed *after* the call site.  So, in principle we
 cannot do the transformation.

 To see whether the code in WS_ENTRY_BB blocks the combined
 parallel+workshare call, we collect all the variables used in the
 GIMPLE_OMP_FOR header check whether they appear on the LHS of any
 statement in WS_ENTRY_BB.  If so, then we cannot emit the combined
 call.

 FIXME.  If we had the SSA form built at this point, we could merely
 hoist the code in block 3 into block 2 and be done with it.  But at
 this point we don't have dataflow information and though we could
 hack something up here, it is really not worth the aggravation.  */

171static bool
172workshare_safe_to_combine_p (basic_block ws_entry_bb)
173{
struct omp_for_data fd;
gimple *ws_stmt = last_stmt (ws_entry_bb);

if (gimple_code (ws_stmt) == GIMPLE_OMP_SECTIONS)
  return true;

gcc_assert (gimple_code (ws_stmt) == GIMPLE_OMP_FOR)((void)(!(gimple_code (ws_stmt) == GIMPLE_OMP_FOR) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 180, __FUNCTION__), 0 : 0));
if (gimple_omp_for_kind (ws_stmt) != GF_OMP_FOR_KIND_FOR)
  return false;

omp_extract_for_data (as_a <gomp_for *> (ws_stmt), &fd, NULLnullptr);

if (fd.collapse > 1 && TREE_CODE (fd.loop.n2)((enum tree_code) (fd.loop.n2)->base.code) != INTEGER_CST)
  return false;
if (fd.iter_type != long_integer_type_nodeinteger_types[itk_long])
  return false;

/* FIXME.  We give up too easily here.  If any of these arguments
   are not constants, they will likely involve variables that have
   been mapped into fields of .omp_data_s for sharing with the child
   function.  With appropriate data flow, it would be possible to
   see through this.  */
if (!is_gimple_min_invariant (fd.loop.n1)
    || !is_gimple_min_invariant (fd.loop.n2)
    || !is_gimple_min_invariant (fd.loop.step)
    || (fd.chunk_size && !is_gimple_min_invariant (fd.chunk_size)))
  return false;

return true;
203}

205/* Adjust CHUNK_SIZE from SCHEDULE clause, depending on simd modifier
 presence (SIMD_SCHEDULE).  */

208static tree
209omp_adjust_chunk_size (tree chunk_size, bool simd_schedule)
210{
if (!simd_schedule || integer_zerop (chunk_size))
  return chunk_size;

poly_uint64 vf = omp_max_vf ();
if (known_eq (vf, 1U)(!maybe_ne (vf, 1U)))
  return chunk_size;

tree type = TREE_TYPE (chunk_size)((contains_struct_check ((chunk_size), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 218, __FUNCTION__))->typed.type);
chunk_size = fold_build2 (PLUS_EXPR, type, chunk_size,fold_build2_loc (((location_t) 0), PLUS_EXPR, type, chunk_size
, build_int_cst (type, vf - 1) )
	    build_int_cst (type, vf - 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, type, chunk_size
, build_int_cst (type, vf - 1) );
return fold_build2 (BIT_AND_EXPR, type, chunk_size,fold_build2_loc (((location_t) 0), BIT_AND_EXPR, type, chunk_size
, build_int_cst (type, -vf) )
      build_int_cst (type, -vf))fold_build2_loc (((location_t) 0), BIT_AND_EXPR, type, chunk_size
, build_int_cst (type, -vf) );
223}

225/* Collect additional arguments needed to emit a combined
 parallel+workshare call.  WS_STMT is the workshare directive being
 expanded.  */

229static vec<tree, va_gc> *
230get_ws_args_for (gimple *par_stmt, gimple *ws_stmt)
231{
tree t;
location_t loc = gimple_location (ws_stmt);
vec<tree, va_gc> *ws_args;

if (gomp_for *for_stmt38.1
'for_stmt' is non-null
1
'for_stmt' is non-null
1
'for_stmt' is non-null
 = dyn_cast <gomp_for *> (ws_stmt))
35
←
Calling 'dyn_cast<gomp_for *, gimple>'→
38
←
Returning from 'dyn_cast<gomp_for *, gimple>'→
39
←
Taking true branch→
  {
    struct omp_for_data fd;
    tree n1, n2;

    omp_extract_for_data (for_stmt, &fd, NULLnullptr);
    n1 = fd.loop.n1;
    n2 = fd.loop.n2;

    if (gimple_omp_for_combined_into_p (for_stmt))
40
←
Taking false branch→
{
 tree innerc
   = omp_find_clause (gimple_omp_parallel_clauses (par_stmt),
	       OMP_CLAUSE__LOOPTEMP_);
 gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 250, __FUNCTION__), 0 : 0));
 n1 = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 251, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 251, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 251, __FUNCTION__)));
 innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 252, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 252, __FUNCTION__))->common.chain),
		    OMP_CLAUSE__LOOPTEMP_);
 gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 254, __FUNCTION__), 0 : 0));
 n2 = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 255, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 255, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 255, __FUNCTION__)));
}

    vec_alloc (ws_args, 3 + (fd.chunk_size != 0));
41
←
Assuming field 'chunk_size' is equal to null→
42
←
Calling 'vec_alloc<tree_node *, va_gc>'→
50
←
Returning from 'vec_alloc<tree_node *, va_gc>'→

    t = fold_convert_loc (loc, long_integer_type_nodeinteger_types[itk_long], n1);
    ws_args->quick_push (t);
51
←
Called C++ object pointer is null

    t = fold_convert_loc (loc, long_integer_type_nodeinteger_types[itk_long], n2);
    ws_args->quick_push (t);

    t = fold_convert_loc (loc, long_integer_type_nodeinteger_types[itk_long], fd.loop.step);
    ws_args->quick_push (t);

    if (fd.chunk_size)
{
 t = fold_convert_loc (loc, long_integer_type_nodeinteger_types[itk_long], fd.chunk_size);
 t = omp_adjust_chunk_size (t, fd.simd_schedule);
 ws_args->quick_push (t);
}

    return ws_args;
  }
else if (gimple_code (ws_stmt) == GIMPLE_OMP_SECTIONS)
  {
    /* Number of sections is equal to the number of edges from the
GIMPLE_OMP_SECTIONS_SWITCH statement, except for the one to
the exit of the sections region.  */
    basic_block bb = single_succ (gimple_bb (ws_stmt));
    t = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], EDGE_COUNT (bb->succs)vec_safe_length (bb->succs) - 1);
    vec_alloc (ws_args, 1);
    ws_args->quick_push (t);
    return ws_args;
  }

gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 290, __FUNCTION__));
291}

293/* Discover whether REGION is a combined parallel+workshare region.  */

295static void
296determine_parallel_type (struct omp_region *region)
297{
basic_block par_entry_bb, par_exit_bb;
basic_block ws_entry_bb, ws_exit_bb;

if (region == NULLnullptr || region->inner == NULLnullptr
17
←
Assuming the condition is false→
    || region->exit == NULLnullptr || region->inner->exit == NULLnullptr
18
←
Assuming the condition is false→
19
←
Assuming the condition is false→
    || region->inner->cont == NULLnullptr)
20
←
Assuming the condition is false→
  return;

/* We only support parallel+for and parallel+sections.  */
if (region->type20.1
Field 'type' is equal to GIMPLE_OMP_PARALLEL
1
Field 'type' is equal to GIMPLE_OMP_PARALLEL
1
Field 'type' is equal to GIMPLE_OMP_PARALLEL
 != GIMPLE_OMP_PARALLEL
    || (region->inner->type != GIMPLE_OMP_FOR
21
←
Assuming field 'type' is equal to GIMPLE_OMP_FOR→
 && region->inner->type != GIMPLE_OMP_SECTIONS))
  return;

/* Check for perfect nesting PAR_ENTRY_BB -> WS_ENTRY_BB and
   WS_EXIT_BB -> PAR_EXIT_BB.  */
par_entry_bb = region->entry;
par_exit_bb = region->exit;
ws_entry_bb = region->inner->entry;
ws_exit_bb = region->inner->exit;

/* Give up for task reductions on the parallel, while it is implementable,
   adding another big set of APIs or slowing down the normal paths is
   not acceptable.  */
tree pclauses = gimple_omp_parallel_clauses (last_stmt (par_entry_bb));
if (omp_find_clause (pclauses, OMP_CLAUSE__REDUCTEMP_))
22
←
Assuming the condition is false→
  return;

if (single_succ (par_entry_bb) == ws_entry_bb
23
←
Assuming the condition is true→
27
←
Taking true branch→
    && single_succ (ws_exit_bb) == par_exit_bb
24
←
Assuming the condition is true→
    && workshare_safe_to_combine_p (ws_entry_bb)
    && (gimple_omp_parallel_combined_p (last_stmt (par_entry_bb))
 || (last_and_only_stmt (ws_entry_bb)
25
←
Assuming the condition is true→
     && last_and_only_stmt (par_exit_bb))))
26
←
Assuming the condition is true→
  {
    gimple *par_stmt = last_stmt (par_entry_bb);
    gimple *ws_stmt = last_stmt (ws_entry_bb);

    if (region->inner->type27.1
Field 'type' is equal to GIMPLE_OMP_FOR
1
Field 'type' is equal to GIMPLE_OMP_FOR
1
Field 'type' is equal to GIMPLE_OMP_FOR
 == GIMPLE_OMP_FOR)
28
←
Taking true branch→
{
 /* If this is a combined parallel loop, we need to determine
    whether or not to use the combined library calls.  There
    are two cases where we do not apply the transformation:
    static loops and any kind of ordered loop.  In the first
    case, we already open code the loop so there is no need
    to do anything else.  In the latter case, the combined
    parallel loop call would still need extra synchronization
    to implement ordered semantics, so there would not be any
    gain in using the combined call.  */
 tree clauses = gimple_omp_for_clauses (ws_stmt);
 tree c = omp_find_clause (clauses, OMP_CLAUSE_SCHEDULE);
 if (c == NULLnullptr
29
←
Assuming the condition is false→
     || ((OMP_CLAUSE_SCHEDULE_KIND (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE_SCHEDULE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 350, __FUNCTION__))->omp_clause.subcode.schedule_kind) & OMP_CLAUSE_SCHEDULE_MASK)
30
←
Assuming the condition is false→
  == OMP_CLAUSE_SCHEDULE_STATIC)
     || omp_find_clause (clauses, OMP_CLAUSE_ORDERED)
31
←
Assuming the condition is false→
     || omp_find_clause (clauses, OMP_CLAUSE__REDUCTEMP_)
32
←
Assuming the condition is false→
     || ((c = omp_find_clause (clauses, OMP_CLAUSE__CONDTEMP_))
33
←
Assuming 'c' is null→
  && POINTER_TYPE_P (TREE_TYPE (OMP_CLAUSE_DECL (c)))(((enum tree_code) (((contains_struct_check (((*(omp_clause_elt_check
 (((omp_clause_range_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check (((*(omp_clause_elt_check
 (((omp_clause_range_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 355, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)))
   return;
}
    else if (region->inner->type == GIMPLE_OMP_SECTIONS
      && (omp_find_clause (gimple_omp_sections_clauses (ws_stmt),
		    OMP_CLAUSE__REDUCTEMP_)
   || omp_find_clause (gimple_omp_sections_clauses (ws_stmt),
		       OMP_CLAUSE__CONDTEMP_)))
return;

    region->is_combined_parallel = true;
    region->inner->is_combined_parallel = true;
    region->ws_args = get_ws_args_for (par_stmt, ws_stmt);
34
←
Calling 'get_ws_args_for'→
  }
369}

371/* Debugging dumps for parallel regions.  */
372void dump_omp_region (FILE *, struct omp_region *, int);
373void debug_omp_region (struct omp_region *);
374void debug_all_omp_regions (void);

376/* Dump the parallel region tree rooted at REGION.  */

378void
379dump_omp_region (FILE *file, struct omp_region *region, int indent)
380{
fprintf (file, "%*sbb %d: %s\n", indent, "", region->entry->index,
  gimple_code_name[region->type]);

if (region->inner)
  dump_omp_region (file, region->inner, indent + 4);

if (region->cont)
  {
    fprintf (file, "%*sbb %d: GIMPLE_OMP_CONTINUE\n", indent, "",
      region->cont->index);
  }

if (region->exit)
  fprintf (file, "%*sbb %d: GIMPLE_OMP_RETURN\n", indent, "",
    region->exit->index);
else
  fprintf (file, "%*s[no exit marker]\n", indent, "");

if (region->next)
  dump_omp_region (file, region->next, indent);
401}

403DEBUG_FUNCTION__attribute__ ((__used__)) void
404debug_omp_region (struct omp_region *region)
405{
dump_omp_region (stderrstderr, region, 0);
407}

409DEBUG_FUNCTION__attribute__ ((__used__)) void
410debug_all_omp_regions (void)
411{
dump_omp_region (stderrstderr, root_omp_region, 0);
413}

415/* Create a new parallel region starting at STMT inside region PARENT.  */

417static struct omp_region *
418new_omp_region (basic_block bb, enum gimple_code type,
struct omp_region *parent)
420{
struct omp_region *region = XCNEW (struct omp_region)((struct omp_region *) xcalloc (1, sizeof (struct omp_region)
));

region->outer = parent;
region->entry = bb;
region->type = type;

if (parent)
  {
    /* This is a nested region.  Add it to the list of inner
regions in PARENT.  */
    region->next = parent->inner;
    parent->inner = region;
  }
else
  {
    /* This is a toplevel region.  Add it to the list of toplevel
regions in ROOT_OMP_REGION.  */
    region->next = root_omp_region;
    root_omp_region = region;
  }

return region;
443}

445/* Release the memory associated with the region tree rooted at REGION.  */

447static void
448free_omp_region_1 (struct omp_region *region)
449{
struct omp_region *i, *n;

for (i = region->inner; i ; i = n)
  {
    n = i->next;
    free_omp_region_1 (i);
  }

free (region);
459}

461/* Release the memory for the entire omp region tree.  */

463void
464omp_free_regions (void)
465{
struct omp_region *r, *n;
for (r = root_omp_region; r ; r = n)
  {
    n = r->next;
    free_omp_region_1 (r);
  }
root_omp_region = NULLnullptr;
473}

475/* A convenience function to build an empty GIMPLE_COND with just the
 condition.  */

478static gcond *
479gimple_build_cond_empty (tree cond)
480{
enum tree_code pred_code;
tree lhs, rhs;

gimple_cond_get_ops_from_tree (cond, &pred_code, &lhs, &rhs);
return gimple_build_cond (pred_code, lhs, rhs, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
486}

488/* Change DECL_CONTEXT of CHILD_FNDECL to that of the parent function.
 Add CHILD_FNDECL to decl chain of the supercontext of the block
 ENTRY_BLOCK - this is the block which originally contained the
 code from which CHILD_FNDECL was created.
 
 Together, these actions ensure that the debug info for the outlined
 function will be emitted with the correct lexical scope.  */

496static void
497adjust_context_and_scope (struct omp_region *region, tree entry_block,
	  tree child_fndecl)
499{
tree parent_fndecl = NULL_TREE(tree) nullptr;
gimple *entry_stmt;
/* OMP expansion expands inner regions before outer ones, so if
   we e.g. have explicit task region nested in parallel region, when
   expanding the task region current_function_decl will be the original
   source function, but we actually want to use as context the child
   function of the parallel.  */
for (region = region->outer;
     region && parent_fndecl == NULL_TREE(tree) nullptr; region = region->outer)
  switch (region->type)
    {
    case GIMPLE_OMP_PARALLEL:
    case GIMPLE_OMP_TASK:
    case GIMPLE_OMP_TEAMS:
entry_stmt = last_stmt (region->entry);
parent_fndecl = gimple_omp_taskreg_child_fn (entry_stmt);
break;
    case GIMPLE_OMP_TARGET:
entry_stmt = last_stmt (region->entry);
parent_fndecl
 = gimple_omp_target_child_fn (as_a <gomp_target *> (entry_stmt));
break;
    default:
break;
    }

if (parent_fndecl == NULL_TREE(tree) nullptr)
  parent_fndecl = current_function_decl;
DECL_CONTEXT (child_fndecl)((contains_struct_check ((child_fndecl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 528, __FUNCTION__))->decl_minimal.context) = parent_fndecl;

if (entry_block != NULL_TREE(tree) nullptr && TREE_CODE (entry_block)((enum tree_code) (entry_block)->base.code) == BLOCK)
  {
    tree b = BLOCK_SUPERCONTEXT (entry_block)((tree_check ((entry_block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 532, __FUNCTION__, (BLOCK)))->block.supercontext);
    if (TREE_CODE (b)((enum tree_code) (b)->base.code) == BLOCK)
      {
 DECL_CHAIN (child_fndecl)(((contains_struct_check (((contains_struct_check ((child_fndecl
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 535, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 535, __FUNCTION__))->common.chain)) = BLOCK_VARS (b)((tree_check ((b), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 535, __FUNCTION__, (BLOCK)))->block.vars);
 BLOCK_VARS (b)((tree_check ((b), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 536, __FUNCTION__, (BLOCK)))->block.vars) = child_fndecl;
}
  }
539}

541/* Build the function calls to GOMP_parallel etc to actually
 generate the parallel operation.  REGION is the parallel region
 being expanded.  BB is the block where to insert the code.  WS_ARGS
 will be set if this is a call to a combined parallel+workshare
 construct, it contains the list of additional arguments needed by
 the workshare construct.  */

548static void
549expand_parallel_call (struct omp_region *region, basic_block bb,
      gomp_parallel *entry_stmt,
      vec<tree, va_gc> *ws_args)
552{
tree t, t1, t2, val, cond, c, clauses, flags;
gimple_stmt_iterator gsi;
gimple *stmt;
enum built_in_function start_ix;
int start_ix2;
location_t clause_loc;
vec<tree, va_gc> *args;

clauses = gimple_omp_parallel_clauses (entry_stmt);

/* Determine what flavor of GOMP_parallel we will be
   emitting.  */
start_ix = BUILT_IN_GOMP_PARALLEL;
tree rtmp = omp_find_clause (clauses, OMP_CLAUSE__REDUCTEMP_);
if (rtmp)
  start_ix = BUILT_IN_GOMP_PARALLEL_REDUCTIONS;
else if (is_combined_parallel (region))
  {
    switch (region->inner->type)
{
case GIMPLE_OMP_FOR:
 gcc_assert (region->inner->sched_kind != OMP_CLAUSE_SCHEDULE_AUTO)((void)(!(region->inner->sched_kind != OMP_CLAUSE_SCHEDULE_AUTO
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 574, __FUNCTION__), 0 : 0));
 switch (region->inner->sched_kind)
   {
   case OMP_CLAUSE_SCHEDULE_RUNTIME:
     /* For lastprivate(conditional:), our implementation
 requires monotonic behavior.  */
     if (region->inner->has_lastprivate_conditional != 0)
start_ix2 = 3;
     else if ((region->inner->sched_modifiers
       & OMP_CLAUSE_SCHEDULE_NONMONOTONIC) != 0)
start_ix2 = 6;
     else if ((region->inner->sched_modifiers
	& OMP_CLAUSE_SCHEDULE_MONOTONIC) == 0)
start_ix2 = 7;
     else
start_ix2 = 3;
     break;
   case OMP_CLAUSE_SCHEDULE_DYNAMIC:
   case OMP_CLAUSE_SCHEDULE_GUIDED:
     if ((region->inner->sched_modifiers
   & OMP_CLAUSE_SCHEDULE_MONOTONIC) == 0
  && !region->inner->has_lastprivate_conditional)
{
  start_ix2 = 3 + region->inner->sched_kind;
  break;
}
     /* FALLTHRU */
   default:
     start_ix2 = region->inner->sched_kind;
     break;
   }
 start_ix2 += (int) BUILT_IN_GOMP_PARALLEL_LOOP_STATIC;
 start_ix = (enum built_in_function) start_ix2;
 break;
case GIMPLE_OMP_SECTIONS:
 start_ix = BUILT_IN_GOMP_PARALLEL_SECTIONS;
 break;
default:
 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 612, __FUNCTION__));
}
  }

/* By default, the value of NUM_THREADS is zero (selected at run time)
   and there is no conditional.  */
cond = NULL_TREE(tree) nullptr;
val = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0);
flags = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0);

c = omp_find_clause (clauses, OMP_CLAUSE_IF);
if (c)
  cond = OMP_CLAUSE_IF_EXPR (c)(*(omp_clause_elt_check (((omp_clause_subcode_check ((c), (OMP_CLAUSE_IF
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 624, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 624, __FUNCTION__)));

c = omp_find_clause (clauses, OMP_CLAUSE_NUM_THREADS);
if (c)
  {
    val = OMP_CLAUSE_NUM_THREADS_EXPR (c)(*(omp_clause_elt_check (((omp_clause_subcode_check ((c), (OMP_CLAUSE_NUM_THREADS
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 629, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 629, __FUNCTION__)));
    clause_loc = OMP_CLAUSE_LOCATION (c)((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 630, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus;
  }
else
  clause_loc = gimple_location (entry_stmt);

c = omp_find_clause (clauses, OMP_CLAUSE_PROC_BIND);
if (c)
  flags = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], OMP_CLAUSE_PROC_BIND_KIND (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE_PROC_BIND), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 637, __FUNCTION__))->omp_clause.subcode.proc_bind_kind));

/* Ensure 'val' is of the correct type.  */
val = fold_convert_loc (clause_loc, unsigned_type_nodeinteger_types[itk_unsigned_int], val);

/* If we found the clause 'if (cond)', build either
   (cond != 0) or (cond ? val : 1u).  */
if (cond)
  {
    cond = gimple_boolify (cond);

    if (integer_zerop (val))
val = fold_build2_loc (clause_loc,
	   EQ_EXPR, unsigned_type_nodeinteger_types[itk_unsigned_int], cond,
	   build_int_cst (TREE_TYPE (cond)((contains_struct_check ((cond), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 651, __FUNCTION__))->typed.type), 0));
    else
{
 basic_block cond_bb, then_bb, else_bb;
 edge e, e_then, e_else;
 tree tmp_then, tmp_else, tmp_join, tmp_var;

 tmp_var = create_tmp_var (TREE_TYPE (val)((contains_struct_check ((val), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 658, __FUNCTION__))->typed.type));
 if (gimple_in_ssa_p (cfun(cfun + 0)))
   {
     tmp_then = make_ssa_name (tmp_var);
     tmp_else = make_ssa_name (tmp_var);
     tmp_join = make_ssa_name (tmp_var);
   }
 else
   {
     tmp_then = tmp_var;
     tmp_else = tmp_var;
     tmp_join = tmp_var;
   }

 e = split_block_after_labels (bb);
 cond_bb = e->src;
 bb = e->dest;
 remove_edge (e);

 then_bb = create_empty_bb (cond_bb);
 else_bb = create_empty_bb (then_bb);
 set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
 set_immediate_dominator (CDI_DOMINATORS, else_bb, cond_bb);

 stmt = gimple_build_cond_empty (cond);
 gsi = gsi_start_bb (cond_bb);
 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);

 gsi = gsi_start_bb (then_bb);
 expand_omp_build_assign (&gsi, tmp_then, val, true);

 gsi = gsi_start_bb (else_bb);
 expand_omp_build_assign (&gsi, tmp_else,
		   build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 1),
		   true);

 make_edge (cond_bb, then_bb, EDGE_TRUE_VALUE);
 make_edge (cond_bb, else_bb, EDGE_FALSE_VALUE);
 add_bb_to_loop (then_bb, cond_bb->loop_father);
 add_bb_to_loop (else_bb, cond_bb->loop_father);
 e_then = make_edge (then_bb, bb, EDGE_FALLTHRU);
 e_else = make_edge (else_bb, bb, EDGE_FALLTHRU);

 if (gimple_in_ssa_p (cfun(cfun + 0)))
   {
     gphi *phi = create_phi_node (tmp_join, bb);
     add_phi_arg (phi, tmp_then, e_then, UNKNOWN_LOCATION((location_t) 0));
     add_phi_arg (phi, tmp_else, e_else, UNKNOWN_LOCATION((location_t) 0));
   }

 val = tmp_join;
}

    gsi = gsi_start_bb (bb);
    val = force_gimple_operand_gsi (&gsi, val, true, NULL_TREE(tree) nullptr,
		      false, GSI_CONTINUE_LINKING);
  }

gsi = gsi_last_nondebug_bb (bb);
t = gimple_omp_parallel_data_arg (entry_stmt);
if (t == NULLnullptr)
  t1 = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
else
  t1 = build_fold_addr_expr (t)build_fold_addr_expr_loc (((location_t) 0), (t));
tree child_fndecl = gimple_omp_parallel_child_fn (entry_stmt);
t2 = build_fold_addr_expr (child_fndecl)build_fold_addr_expr_loc (((location_t) 0), (child_fndecl));

vec_alloc (args, 4 + vec_safe_length (ws_args));
args->quick_push (t2);
args->quick_push (t1);
args->quick_push (val);
if (ws_args)
  args->splice (*ws_args);
args->quick_push (flags);

t = build_call_expr_loc_vec (UNKNOWN_LOCATION((location_t) 0),
	       builtin_decl_explicit (start_ix), args);

if (rtmp)
  {
    tree type = TREE_TYPE (OMP_CLAUSE_DECL (rtmp))((contains_struct_check (((*(omp_clause_elt_check (((omp_clause_range_check
 (((tree_check ((rtmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 738, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 738, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 738, __FUNCTION__)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 738, __FUNCTION__))->typed.type);
    t = build2 (MODIFY_EXPR, type, OMP_CLAUSE_DECL (rtmp)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((rtmp), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 739, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 739, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 739, __FUNCTION__))),
  fold_convert (type,fold_convert_loc (((location_t) 0), type, fold_convert_loc ((
(location_t) 0), global_trees[TI_POINTER_SIZED_TYPE], t))
		fold_convert (pointer_sized_int_node, t))fold_convert_loc (((location_t) 0), type, fold_convert_loc ((
(location_t) 0), global_trees[TI_POINTER_SIZED_TYPE], t)));
  }
force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
	    false, GSI_CONTINUE_LINKING);
745}

747/* Build the function call to GOMP_task to actually
 generate the task operation.  BB is the block where to insert the code.  */

750static void
751expand_task_call (struct omp_region *region, basic_block bb,
  gomp_task *entry_stmt)
753{
tree t1, t2, t3;
gimple_stmt_iterator gsi;
location_t loc = gimple_location (entry_stmt);

tree clauses = gimple_omp_task_clauses (entry_stmt);

tree ifc = omp_find_clause (clauses, OMP_CLAUSE_IF);
tree untied = omp_find_clause (clauses, OMP_CLAUSE_UNTIED);
tree mergeable = omp_find_clause (clauses, OMP_CLAUSE_MERGEABLE);
tree depend = omp_find_clause (clauses, OMP_CLAUSE_DEPEND);
tree finalc = omp_find_clause (clauses, OMP_CLAUSE_FINAL);
tree priority = omp_find_clause (clauses, OMP_CLAUSE_PRIORITY);
tree detach = omp_find_clause (clauses, OMP_CLAUSE_DETACH);

unsigned int iflags
  = (untied ? GOMP_TASK_FLAG_UNTIED(1 << 0) : 0)
    | (mergeable ? GOMP_TASK_FLAG_MERGEABLE(1 << 2) : 0)
    | (depend ? GOMP_TASK_FLAG_DEPEND(1 << 3) : 0);

bool taskloop_p = gimple_omp_task_taskloop_p (entry_stmt);
tree startvar = NULL_TREE(tree) nullptr, endvar = NULL_TREE(tree) nullptr, step = NULL_TREE(tree) nullptr;
tree num_tasks = NULL_TREE(tree) nullptr;
bool ull = false;
if (taskloop_p)
  {
    gimple *g = last_stmt (region->outer->entry);
    gcc_assert (gimple_code (g) == GIMPLE_OMP_FOR((void)(!(gimple_code (g) == GIMPLE_OMP_FOR && gimple_omp_for_kind
 (g) == GF_OMP_FOR_KIND_TASKLOOP) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 781, __FUNCTION__), 0 : 0))
  && gimple_omp_for_kind (g) == GF_OMP_FOR_KIND_TASKLOOP)((void)(!(gimple_code (g) == GIMPLE_OMP_FOR && gimple_omp_for_kind
 (g) == GF_OMP_FOR_KIND_TASKLOOP) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 781, __FUNCTION__), 0 : 0));
    struct omp_for_data fd;
    omp_extract_for_data (as_a <gomp_for *> (g), &fd, NULLnullptr);
    startvar = omp_find_clause (clauses, OMP_CLAUSE__LOOPTEMP_);
    endvar = omp_find_clause (OMP_CLAUSE_CHAIN (startvar)((contains_struct_check (((tree_check ((startvar), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 785, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 785, __FUNCTION__))->common.chain),
		OMP_CLAUSE__LOOPTEMP_);
    startvar = OMP_CLAUSE_DECL (startvar)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((startvar), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 787, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 787, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 787, __FUNCTION__)));
    endvar = OMP_CLAUSE_DECL (endvar)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((endvar), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 788, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 788, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 788, __FUNCTION__)));
    step = fold_convert_loc (loc, fd.iter_type, fd.loop.step);
    if (fd.loop.cond_code == LT_EXPR)
iflags |= GOMP_TASK_FLAG_UP(1 << 8);
    tree tclauses = gimple_omp_for_clauses (g);
    num_tasks = omp_find_clause (tclauses, OMP_CLAUSE_NUM_TASKS);
    if (num_tasks)
{
 if (OMP_CLAUSE_NUM_TASKS_STRICT (num_tasks)(((omp_clause_subcode_check ((num_tasks), (OMP_CLAUSE_NUM_TASKS
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 796, __FUNCTION__)))->base.private_flag))
   iflags |= GOMP_TASK_FLAG_STRICT(1 << 14);
 num_tasks = OMP_CLAUSE_NUM_TASKS_EXPR (num_tasks)(*(omp_clause_elt_check (((omp_clause_subcode_check ((num_tasks
), (OMP_CLAUSE_NUM_TASKS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 798, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 798, __FUNCTION__)));
}
    else
{
 num_tasks = omp_find_clause (tclauses, OMP_CLAUSE_GRAINSIZE);
 if (num_tasks)
   {
     iflags |= GOMP_TASK_FLAG_GRAINSIZE(1 << 9);
     if (OMP_CLAUSE_GRAINSIZE_STRICT (num_tasks)(((omp_clause_subcode_check ((num_tasks), (OMP_CLAUSE_GRAINSIZE
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 806, __FUNCTION__)))->base.private_flag))
iflags |= GOMP_TASK_FLAG_STRICT(1 << 14);
     num_tasks = OMP_CLAUSE_GRAINSIZE_EXPR (num_tasks)(*(omp_clause_elt_check (((omp_clause_subcode_check ((num_tasks
), (OMP_CLAUSE_GRAINSIZE), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 808, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 808, __FUNCTION__)));
   }
 else
   num_tasks = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];
}
    num_tasks = fold_convert_loc (loc, long_integer_type_nodeinteger_types[itk_long], num_tasks);
    if (ifc == NULL_TREE(tree) nullptr)
iflags |= GOMP_TASK_FLAG_IF(1 << 10);
    if (omp_find_clause (tclauses, OMP_CLAUSE_NOGROUP))
iflags |= GOMP_TASK_FLAG_NOGROUP(1 << 11);
    ull = fd.iter_type == long_long_unsigned_type_nodeinteger_types[itk_unsigned_long_long];
    if (omp_find_clause (clauses, OMP_CLAUSE_REDUCTION))
iflags |= GOMP_TASK_FLAG_REDUCTION(1 << 12);
  }
else
  {
    if (priority)
iflags |= GOMP_TASK_FLAG_PRIORITY(1 << 4);
    if (detach)
iflags |= GOMP_TASK_FLAG_DETACH(1 << 13);
  }

tree flags = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], iflags);

tree cond = boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
if (ifc)
  {
    if (taskloop_p)
{
 tree t = gimple_boolify (OMP_CLAUSE_IF_EXPR (ifc)(*(omp_clause_elt_check (((omp_clause_subcode_check ((ifc), (
OMP_CLAUSE_IF), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 837, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 837, __FUNCTION__))));
 t = fold_build3_loc (loc, COND_EXPR, unsigned_type_nodeinteger_types[itk_unsigned_int], t,
	       build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int],
			      GOMP_TASK_FLAG_IF(1 << 10)),
	       build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0));
 flags = fold_build2_loc (loc, PLUS_EXPR, unsigned_type_nodeinteger_types[itk_unsigned_int],
		   flags, t);
}
    else
cond = gimple_boolify (OMP_CLAUSE_IF_EXPR (ifc)(*(omp_clause_elt_check (((omp_clause_subcode_check ((ifc), (
OMP_CLAUSE_IF), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 846, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 846, __FUNCTION__))));
  }

if (finalc)
  {
    tree t = gimple_boolify (OMP_CLAUSE_FINAL_EXPR (finalc)(*(omp_clause_elt_check (((omp_clause_subcode_check ((finalc)
, (OMP_CLAUSE_FINAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 851, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 851, __FUNCTION__))));
    t = fold_build3_loc (loc, COND_EXPR, unsigned_type_nodeinteger_types[itk_unsigned_int], t,
	   build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int],
			  GOMP_TASK_FLAG_FINAL(1 << 1)),
	   build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0));
    flags = fold_build2_loc (loc, PLUS_EXPR, unsigned_type_nodeinteger_types[itk_unsigned_int], flags, t);
  }
if (depend)
  depend = OMP_CLAUSE_DECL (depend)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((depend), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 859, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 859, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 859, __FUNCTION__)));
else
  depend = build_int_cst (ptr_type_nodeglobal_trees[TI_PTR_TYPE], 0);
if (priority)
  priority = fold_convert (integer_type_node,fold_convert_loc (((location_t) 0), integer_types[itk_int], (
*(omp_clause_elt_check (((omp_clause_subcode_check ((priority
), (OMP_CLAUSE_PRIORITY), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 864, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 864, __FUNCTION__))))
	     OMP_CLAUSE_PRIORITY_EXPR (priority))fold_convert_loc (((location_t) 0), integer_types[itk_int], (
*(omp_clause_elt_check (((omp_clause_subcode_check ((priority
), (OMP_CLAUSE_PRIORITY), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 864, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 864, __FUNCTION__))));
else
  priority = integer_zero_nodeglobal_trees[TI_INTEGER_ZERO];

gsi = gsi_last_nondebug_bb (bb);

detach = (detach
   ? build_fold_addr_expr (OMP_CLAUSE_DECL (detach))build_fold_addr_expr_loc (((location_t) 0), ((*(omp_clause_elt_check
 (((omp_clause_range_check (((tree_check ((detach), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 871, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 871, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 871, __FUNCTION__)))))
   : null_pointer_nodeglobal_trees[TI_NULL_POINTER]);

tree t = gimple_omp_task_data_arg (entry_stmt);
if (t == NULLnullptr)
  t2 = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
else
  t2 = build_fold_addr_expr_loc (loc, t);
t1 = build_fold_addr_expr_loc (loc, gimple_omp_task_child_fn (entry_stmt));
t = gimple_omp_task_copy_fn (entry_stmt);
if (t == NULLnullptr)
  t3 = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
else
  t3 = build_fold_addr_expr_loc (loc, t);

if (taskloop_p)
  t = build_call_expr (ull
	 ? builtin_decl_explicit (BUILT_IN_GOMP_TASKLOOP_ULL)
	 : builtin_decl_explicit (BUILT_IN_GOMP_TASKLOOP),
	 11, t1, t2, t3,
	 gimple_omp_task_arg_size (entry_stmt),
	 gimple_omp_task_arg_align (entry_stmt), flags,
	 num_tasks, priority, startvar, endvar, step);
else
  t = build_call_expr (builtin_decl_explicit (BUILT_IN_GOMP_TASK),
	 10, t1, t2, t3,
	 gimple_omp_task_arg_size (entry_stmt),
	 gimple_omp_task_arg_align (entry_stmt), cond, flags,
	 depend, priority, detach);

force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
	    false, GSI_CONTINUE_LINKING);
903}

905/* Build the function call to GOMP_taskwait_depend to actually
 generate the taskwait operation.  BB is the block where to insert the
 code.  */

909static void
910expand_taskwait_call (basic_block bb, gomp_task *entry_stmt)
911{
tree clauses = gimple_omp_task_clauses (entry_stmt);
tree depend = omp_find_clause (clauses, OMP_CLAUSE_DEPEND);
if (depend == NULL_TREE(tree) nullptr)
  return;

depend = OMP_CLAUSE_DECL (depend)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((depend), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 917, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 917, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 917, __FUNCTION__)));

bool nowait = omp_find_clause (clauses, OMP_CLAUSE_NOWAIT) != NULL_TREE(tree) nullptr;
gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
enum built_in_function f = (nowait
	      ? BUILT_IN_GOMP_TASKWAIT_DEPEND_NOWAIT
	      : BUILT_IN_GOMP_TASKWAIT_DEPEND);
tree t = build_call_expr (builtin_decl_explicit (f), 1, depend);

force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
	    false, GSI_CONTINUE_LINKING);
928}

930/* Build the function call to GOMP_teams_reg to actually
 generate the host teams operation.  REGION is the teams region
 being expanded.  BB is the block where to insert the code.  */

934static void
935expand_teams_call (basic_block bb, gomp_teams *entry_stmt)
936{
tree clauses = gimple_omp_teams_clauses (entry_stmt);
tree num_teams = omp_find_clause (clauses, OMP_CLAUSE_NUM_TEAMS);
if (num_teams == NULL_TREE(tree) nullptr)
  num_teams = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0);
else
  {
    num_teams = OMP_CLAUSE_NUM_TEAMS_UPPER_EXPR (num_teams)(*(omp_clause_elt_check (((omp_clause_subcode_check ((num_teams
), (OMP_CLAUSE_NUM_TEAMS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 943, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 943, __FUNCTION__)));
    num_teams = fold_convert (unsigned_type_node, num_teams)fold_convert_loc (((location_t) 0), integer_types[itk_unsigned_int
], num_teams);
  }
tree thread_limit = omp_find_clause (clauses, OMP_CLAUSE_THREAD_LIMIT);
if (thread_limit == NULL_TREE(tree) nullptr)
  thread_limit = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int], 0);
else
  {
    thread_limit = OMP_CLAUSE_THREAD_LIMIT_EXPR (thread_limit)(*(omp_clause_elt_check (((omp_clause_subcode_check ((thread_limit
), (OMP_CLAUSE_THREAD_LIMIT), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 951, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 951, __FUNCTION__)));
    thread_limit = fold_convert (unsigned_type_node, thread_limit)fold_convert_loc (((location_t) 0), integer_types[itk_unsigned_int
], thread_limit);
  }

gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
tree t = gimple_omp_teams_data_arg (entry_stmt), t1;
if (t == NULLnullptr)
  t1 = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
else
  t1 = build_fold_addr_expr (t)build_fold_addr_expr_loc (((location_t) 0), (t));
tree child_fndecl = gimple_omp_teams_child_fn (entry_stmt);
tree t2 = build_fold_addr_expr (child_fndecl)build_fold_addr_expr_loc (((location_t) 0), (child_fndecl));

vec<tree, va_gc> *args;
vec_alloc (args, 5);
args->quick_push (t2);
args->quick_push (t1);
args->quick_push (num_teams);
args->quick_push (thread_limit);
/* For future extensibility.  */
args->quick_push (build_zero_cst (unsigned_type_nodeinteger_types[itk_unsigned_int]));

t = build_call_expr_loc_vec (UNKNOWN_LOCATION((location_t) 0),
	       builtin_decl_explicit (BUILT_IN_GOMP_TEAMS_REG),
	       args);

force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
	    false, GSI_CONTINUE_LINKING);
979}

981/* Chain all the DECLs in LIST by their TREE_CHAIN fields.  */

983static tree
984vec2chain (vec<tree, va_gc> *v)
985{
tree chain = NULL_TREE(tree) nullptr, t;
unsigned ix;

FOR_EACH_VEC_SAFE_ELT_REVERSE (v, ix, t)for (ix = vec_safe_length (v) - 1; vec_safe_iterate ((v), (ix
), &(t)); (ix)--)
  {
    DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 991, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 991, __FUNCTION__))->common.chain)) = chain;
    chain = t;
  }

return chain;
996}

998/* Remove barriers in REGION->EXIT's block.  Note that this is only
 valid for GIMPLE_OMP_PARALLEL regions.  Since the end of a parallel region
 is an implicit barrier, any workshare inside the GIMPLE_OMP_PARALLEL that
 left a barrier at the end of the GIMPLE_OMP_PARALLEL region can now be
 removed.  */

1004static void
1005remove_exit_barrier (struct omp_region *region)
1006{
gimple_stmt_iterator gsi;
basic_block exit_bb;
edge_iterator ei;
edge e;
gimple *stmt;
int any_addressable_vars = -1;

exit_bb = region->exit;

/* If the parallel region doesn't return, we don't have REGION->EXIT
   block at all.  */
if (! exit_bb)
  return;

/* The last insn in the block will be the parallel's GIMPLE_OMP_RETURN.  The
   workshare's GIMPLE_OMP_RETURN will be in a preceding block.  The kinds of
   statements that can appear in between are extremely limited -- no
   memory operations at all.  Here, we allow nothing at all, so the
   only thing we allow to precede this GIMPLE_OMP_RETURN is a label.  */
gsi = gsi_last_nondebug_bb (exit_bb);
gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1027, __FUNCTION__), 0 : 0));
gsi_prev_nondebug (&gsi);
if (!gsi_end_p (gsi) && gimple_code (gsi_stmt (gsi)) != GIMPLE_LABEL)
  return;

FOR_EACH_EDGE (e, ei, exit_bb->preds)for ((ei) = ei_start_1 (&((exit_bb->preds))); ei_cond (
(ei), &(e)); ei_next (&(ei)))
  {
    gsi = gsi_last_nondebug_bb (e->src);
    if (gsi_end_p (gsi))
continue;
    stmt = gsi_stmt (gsi);
    if (gimple_code (stmt) == GIMPLE_OMP_RETURN
 && !gimple_omp_return_nowait_p (stmt))
{
 /* OpenMP 3.0 tasks unfortunately prevent this optimization
    in many cases.  If there could be tasks queued, the barrier
    might be needed to let the tasks run before some local
    variable of the parallel that the task uses as shared
    runs out of scope.  The task can be spawned either
    from within current function (this would be easy to check)
    or from some function it calls and gets passed an address
    of such a variable.  */
 if (any_addressable_vars < 0)
   {
     gomp_parallel *parallel_stmt
= as_a <gomp_parallel *> (last_stmt (region->entry));
     tree child_fun = gimple_omp_parallel_child_fn (parallel_stmt);
     tree local_decls, block, decl;
     unsigned ix;

     any_addressable_vars = 0;
     FOR_EACH_LOCAL_DECL (DECL_STRUCT_FUNCTION (child_fun), ix, decl)for (ix = vec_safe_length ((((tree_check ((child_fun), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1058, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))
->local_decls) - 1; vec_safe_iterate (((((tree_check ((child_fun
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1058, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f))
->local_decls), (ix), &(decl)); (ix)--)
if (TREE_ADDRESSABLE (decl)((decl)->base.addressable_flag))
  {
    any_addressable_vars = 1;
    break;
  }
     for (block = gimple_block (stmt);
   !any_addressable_vars
   && block
   && TREE_CODE (block)((enum tree_code) (block)->base.code) == BLOCK;
   block = BLOCK_SUPERCONTEXT (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1068, __FUNCTION__, (BLOCK)))->block.supercontext))
{
  for (local_decls = BLOCK_VARS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1070, __FUNCTION__, (BLOCK)))->block.vars);
       local_decls;
       local_decls = DECL_CHAIN (local_decls)(((contains_struct_check (((contains_struct_check ((local_decls
), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1072, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1072, __FUNCTION__))->common.chain)))
    if (TREE_ADDRESSABLE (local_decls)((local_decls)->base.addressable_flag))
      {
	any_addressable_vars = 1;
	break;
      }
  if (block == gimple_block (parallel_stmt))
    break;
}
   }
 if (!any_addressable_vars)
   gimple_omp_return_set_nowait (stmt);
}
  }
1086}

1088static void
1089remove_exit_barriers (struct omp_region *region)
1090{
if (region->type == GIMPLE_OMP_PARALLEL)
  remove_exit_barrier (region);

if (region->inner)
  {
    region = region->inner;
    remove_exit_barriers (region);
    while (region->next)
{
 region = region->next;
 remove_exit_barriers (region);
}
  }
1104}

1106/* Optimize omp_get_thread_num () and omp_get_num_threads ()
 calls.  These can't be declared as const functions, but
 within one parallel body they are constant, so they can be
 transformed there into __builtin_omp_get_{thread_num,num_threads} ()
 which are declared const.  Similarly for task body, except
 that in untied task omp_get_thread_num () can change at any task
 scheduling point.  */

1114static void
1115optimize_omp_library_calls (gimple *entry_stmt)
1116{
basic_block bb;
gimple_stmt_iterator gsi;
tree thr_num_tree = builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM);
tree thr_num_id = DECL_ASSEMBLER_NAME (thr_num_tree)decl_assembler_name (thr_num_tree);
tree num_thr_tree = builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS);
tree num_thr_id = DECL_ASSEMBLER_NAME (num_thr_tree)decl_assembler_name (num_thr_tree);
bool untied_task = (gimple_code (entry_stmt) == GIMPLE_OMP_TASK
      && omp_find_clause (gimple_omp_task_clauses (entry_stmt),
			  OMP_CLAUSE_UNTIED) != NULLnullptr);

FOR_EACH_BB_FN (bb, cfun)for (bb = ((cfun + 0))->cfg->x_entry_block_ptr->next_bb
; bb != ((cfun + 0))->cfg->x_exit_block_ptr; bb = bb->
next_bb)
  for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
    {
gimple *call = gsi_stmt (gsi);
tree decl;

if (is_gimple_call (call)
   && (decl = gimple_call_fndecl (call))
   && DECL_EXTERNAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1135, __FUNCTION__))->decl_common.decl_flag_1)
   && TREE_PUBLIC (decl)((decl)->base.public_flag)
   && DECL_INITIAL (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1137, __FUNCTION__))->decl_common.initial) == NULLnullptr)
 {
   tree built_in;

   if (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1141, __FUNCTION__))->decl_minimal.name) == thr_num_id)
     {
/* In #pragma omp task untied omp_get_thread_num () can change
   during the execution of the task region.  */
if (untied_task)
  continue;
built_in = builtin_decl_explicit (BUILT_IN_OMP_GET_THREAD_NUM);
     }
   else if (DECL_NAME (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1149, __FUNCTION__))->decl_minimal.name) == num_thr_id)
     built_in = builtin_decl_explicit (BUILT_IN_OMP_GET_NUM_THREADS);
   else
     continue;

   if (DECL_ASSEMBLER_NAME (decl)decl_assembler_name (decl) != DECL_ASSEMBLER_NAME (built_in)decl_assembler_name (built_in)
|| gimple_call_num_args (call) != 0)
     continue;

   if (flag_exceptionsglobal_options.x_flag_exceptions && !TREE_NOTHROW (decl)((decl)->base.nothrow_flag))
     continue;

   if (TREE_CODE (TREE_TYPE (decl))((enum tree_code) (((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1161, __FUNCTION__))->typed.type))->base.code) != FUNCTION_TYPE
|| !types_compatible_p (TREE_TYPE (TREE_TYPE (decl))((contains_struct_check ((((contains_struct_check ((decl), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1162, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1162, __FUNCTION__))->typed.type),
			TREE_TYPE (TREE_TYPE (built_in))((contains_struct_check ((((contains_struct_check ((built_in)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1163, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1163, __FUNCTION__))->typed.type)))
     continue;

   gimple_call_set_fndecl (call, built_in);
 }
    }
1169}

1171/* Callback for expand_omp_build_assign.  Return non-NULL if *tp needs to be
 regimplified.  */

1174static tree
1175expand_omp_regimplify_p (tree *tp, int *walk_subtrees, void *)
1176{
tree t = *tp;

/* Any variable with DECL_VALUE_EXPR needs to be regimplified.  */
if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_DECL) && DECL_HAS_VALUE_EXPR_P (t)((tree_check3 ((t), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1180, __FUNCTION__, (VAR_DECL), (PARM_DECL), (RESULT_DECL))
) ->decl_common.decl_flag_2))
  return t;

if (TREE_CODE (t)((enum tree_code) (t)->base.code) == ADDR_EXPR)
  recompute_tree_invariant_for_addr_expr (t);

*walk_subtrees = !TYPE_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_type) && !DECL_P (t)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (t)->base.code))] == tcc_declaration);
return NULL_TREE(tree) nullptr;
1188}

1190/* Prepend or append TO = FROM assignment before or after *GSI_P.  */

1192static void
1193expand_omp_build_assign (gimple_stmt_iterator *gsi_p, tree to, tree from,
	 bool after)
1195{
bool simple_p = DECL_P (to)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (to)->base.code))] == tcc_declaration) && TREE_ADDRESSABLE (to)((to)->base.addressable_flag);
from = force_gimple_operand_gsi (gsi_p, from, simple_p, NULL_TREE(tree) nullptr,
		   !after, after ? GSI_CONTINUE_LINKING
				 : GSI_SAME_STMT);
gimple *stmt = gimple_build_assign (to, from);
if (after)
  gsi_insert_after (gsi_p, stmt, GSI_CONTINUE_LINKING);
else
  gsi_insert_before (gsi_p, stmt, GSI_SAME_STMT);
if (walk_tree (&from, expand_omp_regimplify_p, NULL, NULL)walk_tree_1 (&from, expand_omp_regimplify_p, nullptr, nullptr
, nullptr)
    || walk_tree (&to, expand_omp_regimplify_p, NULL, NULL)walk_tree_1 (&to, expand_omp_regimplify_p, nullptr, nullptr
, nullptr))
  {
    gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
    gimple_regimplify_operands (stmt, &gsi);
  }
1211}

1213/* Prepend or append LHS CODE RHS condition before or after *GSI_P.  */

1215static gcond *
1216expand_omp_build_cond (gimple_stmt_iterator *gsi_p, enum tree_code code,
       tree lhs, tree rhs, bool after = false)
1218{
gcond *cond_stmt = gimple_build_cond (code, lhs, rhs, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
if (after)
  gsi_insert_after (gsi_p, cond_stmt, GSI_CONTINUE_LINKING);
else
  gsi_insert_before (gsi_p, cond_stmt, GSI_SAME_STMT);
if (walk_tree (gimple_cond_lhs_ptr (cond_stmt), expand_omp_regimplify_p,walk_tree_1 (gimple_cond_lhs_ptr (cond_stmt), expand_omp_regimplify_p
, nullptr, nullptr, nullptr)
 NULL, NULL)walk_tree_1 (gimple_cond_lhs_ptr (cond_stmt), expand_omp_regimplify_p
, nullptr, nullptr, nullptr)
    || walk_tree (gimple_cond_rhs_ptr (cond_stmt), expand_omp_regimplify_p,walk_tree_1 (gimple_cond_rhs_ptr (cond_stmt), expand_omp_regimplify_p
, nullptr, nullptr, nullptr)
    NULL, NULL)walk_tree_1 (gimple_cond_rhs_ptr (cond_stmt), expand_omp_regimplify_p
, nullptr, nullptr, nullptr))
  {
    gimple_stmt_iterator gsi = gsi_for_stmt (cond_stmt);
    gimple_regimplify_operands (cond_stmt, &gsi);
  }
return cond_stmt;
1233}

1235/* Expand the OpenMP parallel or task directive starting at REGION.  */

1237static void
1238expand_omp_taskreg (struct omp_region *region)
1239{
basic_block entry_bb, exit_bb, new_bb;
struct function *child_cfun;
tree child_fn, block, t;
gimple_stmt_iterator gsi;
gimple *entry_stmt, *stmt;
edge e;
vec<tree, va_gc> *ws_args;

entry_stmt = last_stmt (region->entry);
if (gimple_code (entry_stmt) == GIMPLE_OMP_TASK
    && gimple_omp_task_taskwait_p (entry_stmt))
  {
    new_bb = region->entry;
    gsi = gsi_last_nondebug_bb (region->entry);
    gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1254, __FUNCTION__), 0 : 0));
    gsi_remove (&gsi, true);
    expand_taskwait_call (new_bb, as_a <gomp_task *> (entry_stmt));
    return;
  }

child_fn = gimple_omp_taskreg_child_fn (entry_stmt);
child_cfun = DECL_STRUCT_FUNCTION (child_fn)((tree_check ((child_fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1261, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f);

entry_bb = region->entry;
if (gimple_code (entry_stmt) == GIMPLE_OMP_TASK)
  exit_bb = region->cont;
else
  exit_bb = region->exit;

if (is_combined_parallel (region))
  ws_args = region->ws_args;
else
  ws_args = NULLnullptr;

if (child_cfun->cfg)
  {
    /* Due to inlining, it may happen that we have already outlined
the region, in which case all we need to do is make the
sub-graph unreachable and emit the parallel call.  */
    edge entry_succ_e, exit_succ_e;

    entry_succ_e = single_succ_edge (entry_bb);

    gsi = gsi_last_nondebug_bb (entry_bb);
    gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_PARALLEL((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_PARALLEL
 || gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK || gimple_code
 (gsi_stmt (gsi)) == GIMPLE_OMP_TEAMS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1286, __FUNCTION__), 0 : 0))
  || gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_PARALLEL
 || gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK || gimple_code
 (gsi_stmt (gsi)) == GIMPLE_OMP_TEAMS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1286, __FUNCTION__), 0 : 0))
  || gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TEAMS)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_PARALLEL
 || gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_TASK || gimple_code
 (gsi_stmt (gsi)) == GIMPLE_OMP_TEAMS) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1286, __FUNCTION__), 0 : 0));
    gsi_remove (&gsi, true);

    new_bb = entry_bb;
    if (exit_bb)
{
 exit_succ_e = single_succ_edge (exit_bb);
 make_edge (new_bb, exit_succ_e->dest, EDGE_FALLTHRU);
}
    remove_edge_and_dominated_blocks (entry_succ_e);
  }
else
  {
    unsigned srcidx, dstidx, num;

    /* If the parallel region needs data sent from the parent
function, then the very first statement (except possible
tree profile counter updates) of the parallel body
is a copy assignment .OMP_DATA_I = &.OMP_DATA_O.  Since
&.OMP_DATA_O is passed as an argument to the child function,
we need to replace it with the argument as seen by the child
function.

In most cases, this will end up being the identity assignment
.OMP_DATA_I = .OMP_DATA_I.  However, if the parallel body had
a function call that has been inlined, the original PARM_DECL
.OMP_DATA_I may have been converted into a different local
variable.  In which case, we need to keep the assignment.  */
    if (gimple_omp_taskreg_data_arg (entry_stmt))
{
 basic_block entry_succ_bb
   = single_succ_p (entry_bb) ? single_succ (entry_bb)
		       : FALLTHRU_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(0)] : (*((entry_bb))->succs)
[(1)])->dest;
 tree arg;
 gimple *parcopy_stmt = NULLnullptr;

 for (gsi = gsi_start_bb (entry_succ_bb); ; gsi_next (&gsi))
   {
     gimple *stmt;

     gcc_assert (!gsi_end_p (gsi))((void)(!(!gsi_end_p (gsi)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1326, __FUNCTION__), 0 : 0));
     stmt = gsi_stmt (gsi);
     if (gimple_code (stmt) != GIMPLE_ASSIGN)
continue;

     if (gimple_num_ops (stmt) == 2)
{
  tree arg = gimple_assign_rhs1 (stmt);

  /* We're ignore the subcode because we're
     effectively doing a STRIP_NOPS.  */

  if (TREE_CODE (arg)((enum tree_code) (arg)->base.code) == ADDR_EXPR
      && (TREE_OPERAND (arg, 0)(*((const_cast<tree*> (tree_operand_check ((arg), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1339, __FUNCTION__)))))
	  == gimple_omp_taskreg_data_arg (entry_stmt)))
    {
      parcopy_stmt = stmt;
      break;
    }
}
   }

 gcc_assert (parcopy_stmt != NULL)((void)(!(parcopy_stmt != nullptr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1348, __FUNCTION__), 0 : 0));
 arg = DECL_ARGUMENTS (child_fn)((tree_check ((child_fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1349, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
);

 if (!gimple_in_ssa_p (cfun(cfun + 0)))
   {
     if (gimple_assign_lhs (parcopy_stmt) == arg)
gsi_remove (&gsi, true);
     else
{
  /* ?? Is setting the subcode really necessary ??  */
  gimple_omp_set_subcode (parcopy_stmt, TREE_CODE (arg)((enum tree_code) (arg)->base.code));
  gimple_assign_set_rhs1 (parcopy_stmt, arg);
}
   }
 else
   {
     tree lhs = gimple_assign_lhs (parcopy_stmt);
     gcc_assert (SSA_NAME_VAR (lhs) == arg)((void)(!(((tree_check ((lhs), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1365, __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) == arg) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1365, __FUNCTION__), 0 : 0));
     /* We'd like to set the rhs to the default def in the child_fn,
 but it's too early to create ssa names in the child_fn.
 Instead, we set the rhs to the parm.  In
 move_sese_region_to_fn, we introduce a default def for the
 parm, map the parm to it's default def, and once we encounter
 this stmt, replace the parm with the default def.  */
     gimple_assign_set_rhs1 (parcopy_stmt, arg);
     update_stmt (parcopy_stmt);
   }
}

    /* Declare local variables needed in CHILD_CFUN.  */
    block = DECL_INITIAL (child_fn)((contains_struct_check ((child_fn), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1378, __FUNCTION__))->decl_common.initial);
    BLOCK_VARS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1379, __FUNCTION__, (BLOCK)))->block.vars) = vec2chain (child_cfun->local_decls);
    /* The gimplifier could record temporaries in parallel/task block
rather than in containing function's local_decls chain,
which would mean cgraph missed finalizing them.  Do it now.  */
    for (t = BLOCK_VARS (block)((tree_check ((block), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1383, __FUNCTION__, (BLOCK)))->block.vars); t; t = DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1383, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1383, __FUNCTION__))->common.chain)))
if (VAR_P (t)(((enum tree_code) (t)->base.code) == VAR_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/omp-expand.cc"
, 1384, __FUNCTION__))->decl_common.decl_flag_1))
 varpool_node::finalize_decl (t);
    DECL_SAVED_TREE (child_fn)((tree_check ((child_fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1386, __FUNCTION__, (FUNCTION_DECL)))->function_decl.saved_tree
) = NULLnullptr;
    /* We'll create a CFG for child_fn, so no gimple body is needed.  */
    gimple_set_body (child_fn, NULLnullptr);
    TREE_USED (block)((block)->base.used_flag) = 1;

    /* Reset DECL_CONTEXT on function arguments.  */
    for (t = DECL_ARGUMENTS (child_fn)((tree_check ((child_fn), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1392, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
); t; t = DECL_CHAIN (t)(((contains_struct_check (((contains_struct_check ((t), (TS_DECL_MINIMAL
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1392, __FUNCTION__))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1392, __FUNCTION__))->common.chain)))
DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1393, __FUNCTION__))->decl_minimal.context) = child_fn;

    /* Split ENTRY_BB at GIMPLE_OMP_PARALLEL or GIMPLE_OMP_TASK,
so that it can be moved to the child function.  */
    gsi = gsi_last_nondebug_bb (entry_bb);
    stmt = gsi_stmt (gsi);
    gcc_assert (stmt && (gimple_code (stmt) == GIMPLE_OMP_PARALLEL((void)(!(stmt && (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
 || gimple_code (stmt) == GIMPLE_OMP_TASK || gimple_code (stmt
) == GIMPLE_OMP_TEAMS)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1401, __FUNCTION__), 0 : 0))
	   || gimple_code (stmt) == GIMPLE_OMP_TASK((void)(!(stmt && (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
 || gimple_code (stmt) == GIMPLE_OMP_TASK || gimple_code (stmt
) == GIMPLE_OMP_TEAMS)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1401, __FUNCTION__), 0 : 0))
	   || gimple_code (stmt) == GIMPLE_OMP_TEAMS))((void)(!(stmt && (gimple_code (stmt) == GIMPLE_OMP_PARALLEL
 || gimple_code (stmt) == GIMPLE_OMP_TASK || gimple_code (stmt
) == GIMPLE_OMP_TEAMS)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1401, __FUNCTION__), 0 : 0));
    e = split_block (entry_bb, stmt);
    gsi_remove (&gsi, true);
    entry_bb = e->dest;
    edge e2 = NULLnullptr;
    if (gimple_code (entry_stmt) != GIMPLE_OMP_TASK)
single_succ_edge (entry_bb)->flags = EDGE_FALLTHRU;
    else
{
 e2 = make_edge (e->src, BRANCH_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(1)] : (*((entry_bb))->succs)
[(0)])->dest, EDGE_ABNORMAL);
 gcc_assert (e2->dest == region->exit)((void)(!(e2->dest == region->exit) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1411, __FUNCTION__), 0 : 0));
 remove_edge (BRANCH_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(1)] : (*((entry_bb))->succs)
[(0)]));
 set_immediate_dominator (CDI_DOMINATORS, e2->dest, e->src);
 gsi = gsi_last_nondebug_bb (region->exit);
 gcc_assert (!gsi_end_p (gsi)((void)(!(!gsi_end_p (gsi) && gimple_code (gsi_stmt (
gsi)) == GIMPLE_OMP_RETURN) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1416, __FUNCTION__), 0 : 0))
      && gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_RETURN)((void)(!(!gsi_end_p (gsi) && gimple_code (gsi_stmt (
gsi)) == GIMPLE_OMP_RETURN) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1416, __FUNCTION__), 0 : 0));
 gsi_remove (&gsi, true);
}

    /* Convert GIMPLE_OMP_{RETURN,CONTINUE} into a RETURN_EXPR.  */
    if (exit_bb)
{
 gsi = gsi_last_nondebug_bb (exit_bb);
 gcc_assert (!gsi_end_p (gsi)((void)(!(!gsi_end_p (gsi) && (gimple_code (gsi_stmt (
gsi)) == (e2 ? GIMPLE_OMP_CONTINUE : GIMPLE_OMP_RETURN))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1426, __FUNCTION__), 0 : 0))
      && (gimple_code (gsi_stmt (gsi))((void)(!(!gsi_end_p (gsi) && (gimple_code (gsi_stmt (
gsi)) == (e2 ? GIMPLE_OMP_CONTINUE : GIMPLE_OMP_RETURN))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1426, __FUNCTION__), 0 : 0))
	  == (e2 ? GIMPLE_OMP_CONTINUE : GIMPLE_OMP_RETURN)))((void)(!(!gsi_end_p (gsi) && (gimple_code (gsi_stmt (
gsi)) == (e2 ? GIMPLE_OMP_CONTINUE : GIMPLE_OMP_RETURN))) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1426, __FUNCTION__), 0 : 0));
 stmt = gimple_build_return (NULLnullptr);
 gsi_insert_after (&gsi, stmt, GSI_SAME_STMT);
 gsi_remove (&gsi, true);
}

    /* Move the parallel region into CHILD_CFUN.  */

    if (gimple_in_ssa_p (cfun(cfun + 0)))
{
 init_tree_ssa (child_cfun);
 init_ssa_operands (child_cfun);
 child_cfun->gimple_df->in_ssa_p = true;
 block = NULL_TREE(tree) nullptr;
}
    else
block = gimple_block (entry_stmt);

    new_bb = move_sese_region_to_fn (child_cfun, entry_bb, exit_bb, block);
    if (exit_bb)
single_succ_edge (new_bb)->flags = EDGE_FALLTHRU;
    if (e2)
{
 basic_block dest_bb = e2->dest;
 if (!exit_bb)
   make_edge (new_bb, dest_bb, EDGE_FALLTHRU);
 remove_edge (e2);
 set_immediate_dominator (CDI_DOMINATORS, dest_bb, new_bb);
}
    /* When the OMP expansion process cannot guarantee an up-to-date
loop tree arrange for the child function to fixup loops.  */
    if (loops_state_satisfies_p (LOOPS_NEED_FIXUP))
child_cfun->x_current_loops->state |= LOOPS_NEED_FIXUP;

    /* Remove non-local VAR_DECLs from child_cfun->local_decls list.  */
    num = vec_safe_length (child_cfun->local_decls);
    for (srcidx = 0, dstidx = 0; srcidx < num; srcidx++)
{
 t = (*child_cfun->local_decls)[srcidx];
 if (DECL_CONTEXT (t)((contains_struct_check ((t), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1465, __FUNCTION__))->decl_minimal.context) == cfun(cfun + 0)->decl)
   continue;
 if (srcidx != dstidx)
   (*child_cfun->local_decls)[dstidx] = t;
 dstidx++;
}
    if (dstidx != num)
vec_safe_truncate (child_cfun->local_decls, dstidx);

    /* Inform the callgraph about the new function.  */
    child_cfun->curr_properties = cfun(cfun + 0)->curr_properties;
    child_cfun->has_simduid_loops |= cfun(cfun + 0)->has_simduid_loops;
    child_cfun->has_force_vectorize_loops |= cfun(cfun + 0)->has_force_vectorize_loops;
    cgraph_node *node = cgraph_node::get_create (child_fn);
    node->parallelized_function = 1;
    cgraph_node::add_new_function (child_fn, true);

    bool need_asm = DECL_ASSEMBLER_NAME_SET_P (current_function_decl)(((contains_struct_check ((current_function_decl), (TS_DECL_WITH_VIS
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1482, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr)
      && !DECL_ASSEMBLER_NAME_SET_P (child_fn)(((contains_struct_check ((child_fn), (TS_DECL_WITH_VIS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1483, __FUNCTION__))->decl_with_vis.assembler_name) != (
tree) nullptr);

    /* Fix the callgraph edges for child_cfun.  Those for cfun will be
fixed in a following pass.  */
    push_cfun (child_cfun);
    if (need_asm)
assign_assembler_name_if_needed (child_fn);

    if (optimizeglobal_options.x_optimize)
optimize_omp_library_calls (entry_stmt);
    update_max_bb_count ();
    cgraph_edge::rebuild_edges ();

    /* Some EH regions might become dead, see PR34608.  If
pass_cleanup_cfg isn't the first pass to happen with the
new child, these dead EH edges might cause problems.
Clean them up now.  */
    if (flag_exceptionsglobal_options.x_flag_exceptions)
{
 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)
   changed |= gimple_purge_dead_eh_edges (bb);
 if (changed)
   cleanup_tree_cfg ();
}
    if (gimple_in_ssa_p (cfun(cfun + 0)))
update_ssa (TODO_update_ssa(1 << 11));
    if (flag_checkingglobal_options.x_flag_checking && !loops_state_satisfies_p (LOOPS_NEED_FIXUP))
verify_loop_structure ();
    pop_cfun ();

    if (dump_file && !gimple_in_ssa_p (cfun(cfun + 0)))
{
 omp_any_child_fn_dumped = true;
 dump_function_header (dump_file, child_fn, dump_flags);
 dump_function_to_file (child_fn, dump_file, dump_flags);
}
  }

adjust_context_and_scope (region, gimple_block (entry_stmt), child_fn);

if (gimple_code (entry_stmt) == GIMPLE_OMP_PARALLEL)
  expand_parallel_call (region, new_bb,
	  as_a <gomp_parallel *> (entry_stmt), ws_args);
else if (gimple_code (entry_stmt) == GIMPLE_OMP_TEAMS)
  expand_teams_call (new_bb, as_a <gomp_teams *> (entry_stmt));
else
  expand_task_call (region, new_bb, as_a <gomp_task *> (entry_stmt));
1533}

1535/* Information about members of an OpenACC collapsed loop nest.  */

1537struct oacc_collapse
1538{
tree base;  /* Base value.  */
tree iters; /* Number of steps.  */
tree step;  /* Step size.  */
tree tile;  /* Tile increment (if tiled).  */
tree outer; /* Tile iterator var. */
1544};

1546/* Helper for expand_oacc_for.  Determine collapsed loop information.
 Fill in COUNTS array.  Emit any initialization code before GSI.
 Return the calculated outer loop bound of BOUND_TYPE.  */

1550static tree
1551expand_oacc_collapse_init (const struct omp_for_data *fd,
	   gimple_stmt_iterator *gsi,
	   oacc_collapse *counts, tree diff_type,
	   tree bound_type, location_t loc)
1555{
tree tiling = fd->tiling;
tree total = build_int_cst (bound_type, 1);
int ix;

gcc_assert (integer_onep (fd->loop.step))((void)(!(integer_onep (fd->loop.step)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1560, __FUNCTION__), 0 : 0));
gcc_assert (integer_zerop (fd->loop.n1))((void)(!(integer_zerop (fd->loop.n1)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1561, __FUNCTION__), 0 : 0));

/* When tiling, the first operand of the tile clause applies to the
   innermost loop, and we work outwards from there.  Seems
   backwards, but whatever.  */
for (ix = fd->collapse; ix--;)
  {
    const omp_for_data_loop *loop = &fd->loops[ix];

    tree iter_type = TREE_TYPE (loop->v)((contains_struct_check ((loop->v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1570, __FUNCTION__))->typed.type);
    tree plus_type = iter_type;

    gcc_assert (loop->cond_code == LT_EXPR || loop->cond_code == GT_EXPR)((void)(!(loop->cond_code == LT_EXPR || loop->cond_code
 == GT_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1573, __FUNCTION__), 0 : 0));

    if (POINTER_TYPE_P (iter_type)(((enum tree_code) (iter_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (iter_type)->base.code) == REFERENCE_TYPE
))
plus_type = sizetypesizetype_tab[(int) stk_sizetype];

    if (tiling)
{
 tree num = build_int_cst (integer_type_nodeinteger_types[itk_int], fd->collapse);
 tree loop_no = build_int_cst (integer_type_nodeinteger_types[itk_int], ix);
 tree tile = TREE_VALUE (tiling)((tree_check ((tiling), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1582, __FUNCTION__, (TREE_LIST)))->list.value);
 gcall *call
   = gimple_build_call_internal (IFN_GOACC_TILE, 5, num, loop_no, tile,
			  /* gwv-outer=*/integer_zero_nodeglobal_trees[TI_INTEGER_ZERO],
			  /* gwv-inner=*/integer_zero_nodeglobal_trees[TI_INTEGER_ZERO]);

 counts[ix].outer = create_tmp_var (iter_type, ".outer");
 counts[ix].tile = create_tmp_var (diff_type, ".tile");
 gimple_call_set_lhs (call, counts[ix].tile);
 gimple_set_location (call, loc);
 gsi_insert_before (gsi, call, GSI_SAME_STMT);

 tiling = TREE_CHAIN (tiling)((contains_struct_check ((tiling), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1594, __FUNCTION__))->common.chain);
}
    else
{
 counts[ix].tile = NULLnullptr;
 counts[ix].outer = loop->v;
}

    tree b = loop->n1;
    tree e = loop->n2;
    tree s = loop->step;
    bool up = loop->cond_code == LT_EXPR;
    tree dir = build_int_cst (diff_type, up ? +1 : -1);
    bool negating;
    tree expr;

    b = force_gimple_operand_gsi (gsi, b, true, NULL_TREE(tree) nullptr,
		    true, GSI_SAME_STMT);
    e = force_gimple_operand_gsi (gsi, e, true, NULL_TREE(tree) nullptr,
		    true, GSI_SAME_STMT);

    /* Convert the step, avoiding possible unsigned->signed overflow.  */
    negating = !up && TYPE_UNSIGNED (TREE_TYPE (s))((tree_class_check ((((contains_struct_check ((s), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1616, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1616, __FUNCTION__))->base.u.bits.unsigned_flag);
    if (negating)
s = fold_build1 (NEGATE_EXPR, TREE_TYPE (s), s)fold_build1_loc (((location_t) 0), NEGATE_EXPR, ((contains_struct_check
 ((s), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1618, __FUNCTION__))->typed.type), s );
    s = fold_convert (diff_type, s)fold_convert_loc (((location_t) 0), diff_type, s);
    if (negating)
s = fold_build1 (NEGATE_EXPR, diff_type, s)fold_build1_loc (((location_t) 0), NEGATE_EXPR, diff_type, s );
    s = force_gimple_operand_gsi (gsi, s, true, NULL_TREE(tree) nullptr,
		    true, GSI_SAME_STMT);

    /* Determine the range, avoiding possible unsigned->signed overflow.  */
    negating = !up && TYPE_UNSIGNED (iter_type)((tree_class_check ((iter_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1626, __FUNCTION__))->base.u.bits.unsigned_flag);
    expr = fold_build2 (MINUS_EXPR, plus_type,fold_build2_loc (((location_t) 0), MINUS_EXPR, plus_type, fold_convert_loc
 (((location_t) 0), plus_type, negating ? b : e), fold_convert_loc
 (((location_t) 0), plus_type, negating ? e : b) )
	  fold_convert (plus_type, negating ? b : e),fold_build2_loc (((location_t) 0), MINUS_EXPR, plus_type, fold_convert_loc
 (((location_t) 0), plus_type, negating ? b : e), fold_convert_loc
 (((location_t) 0), plus_type, negating ? e : b) )
	  fold_convert (plus_type, negating ? e : b))fold_build2_loc (((location_t) 0), MINUS_EXPR, plus_type, fold_convert_loc
 (((location_t) 0), plus_type, negating ? b : e), fold_convert_loc
 (((location_t) 0), plus_type, negating ? e : b) );
    expr = fold_convert (diff_type, expr)fold_convert_loc (((location_t) 0), diff_type, expr);
    if (negating)
expr = fold_build1 (NEGATE_EXPR, diff_type, expr)fold_build1_loc (((location_t) 0), NEGATE_EXPR, diff_type, expr
 );
    tree range = force_gimple_operand_gsi
(gsi, expr, true, NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);

    /* Determine number of iterations.  */
    expr = fold_build2 (MINUS_EXPR, diff_type, range, dir)fold_build2_loc (((location_t) 0), MINUS_EXPR, diff_type, range
, dir );
    expr = fold_build2 (PLUS_EXPR, diff_type, expr, s)fold_build2_loc (((location_t) 0), PLUS_EXPR, diff_type, expr
, s );
    expr = fold_build2 (TRUNC_DIV_EXPR, diff_type, expr, s)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, diff_type,
 expr, s );

    tree iters = force_gimple_operand_gsi (gsi, expr, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);

    counts[ix].base = b;
    counts[ix].iters = iters;
    counts[ix].step = s;

    total = fold_build2 (MULT_EXPR, bound_type, total,fold_build2_loc (((location_t) 0), MULT_EXPR, bound_type, total
, fold_convert_loc (((location_t) 0), bound_type, iters) )
	   fold_convert (bound_type, iters))fold_build2_loc (((location_t) 0), MULT_EXPR, bound_type, total
, fold_convert_loc (((location_t) 0), bound_type, iters) );
  }

return total;
1653}

1655/* Emit initializers for collapsed loop members.  INNER is true if
 this is for the element loop of a TILE.  IVAR is the outer
 loop iteration variable, from which collapsed loop iteration values
 are  calculated.  COUNTS array has been initialized by
 expand_oacc_collapse_inits.  */

1661static void
1662expand_oacc_collapse_vars (const struct omp_for_data *fd, bool inner,
	   gimple_stmt_iterator *gsi,
	   const oacc_collapse *counts, tree ivar,
	   tree diff_type)
1666{
tree ivar_type = TREE_TYPE (ivar)((contains_struct_check ((ivar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1667, __FUNCTION__))->typed.type);

/*  The most rapidly changing iteration variable is the innermost
    one.  */
for (int ix = fd->collapse; ix--;)
  {
    const omp_for_data_loop *loop = &fd->loops[ix];
    const oacc_collapse *collapse = &counts[ix];
    tree v = inner ? loop->v : collapse->outer;
    tree iter_type = TREE_TYPE (v)((contains_struct_check ((v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1676, __FUNCTION__))->typed.type);
    tree plus_type = iter_type;
    enum tree_code plus_code = PLUS_EXPR;
    tree expr;

    if (POINTER_TYPE_P (iter_type)(((enum tree_code) (iter_type)->base.code) == POINTER_TYPE
 || ((enum tree_code) (iter_type)->base.code) == REFERENCE_TYPE
))
{
 plus_code = POINTER_PLUS_EXPR;
 plus_type = sizetypesizetype_tab[(int) stk_sizetype];
}

    expr = ivar;
    if (ix)
{
 tree mod = fold_convert (ivar_type, collapse->iters)fold_convert_loc (((location_t) 0), ivar_type, collapse->iters
);
 ivar = fold_build2 (TRUNC_DIV_EXPR, ivar_type, expr, mod)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, ivar_type,
 expr, mod );
 expr = fold_build2 (TRUNC_MOD_EXPR, ivar_type, expr, mod)fold_build2_loc (((location_t) 0), TRUNC_MOD_EXPR, ivar_type,
 expr, mod );
 ivar = force_gimple_operand_gsi (gsi, ivar, true, NULL_TREE(tree) nullptr,
			   true, GSI_SAME_STMT);
}

    expr = fold_build2 (MULT_EXPR, diff_type, fold_convert (diff_type, expr),fold_build2_loc (((location_t) 0), MULT_EXPR, diff_type, fold_convert_loc
 (((location_t) 0), diff_type, expr), fold_convert_loc (((location_t
) 0), diff_type, collapse->step) )
	  fold_convert (diff_type, collapse->step))fold_build2_loc (((location_t) 0), MULT_EXPR, diff_type, fold_convert_loc
 (((location_t) 0), diff_type, expr), fold_convert_loc (((location_t
) 0), diff_type, collapse->step) );
    expr = fold_build2 (plus_code, iter_type,fold_build2_loc (((location_t) 0), plus_code, iter_type, inner
 ? collapse->outer : collapse->base, fold_convert_loc (
((location_t) 0), plus_type, expr) )
	  inner ? collapse->outer : collapse->base,fold_build2_loc (((location_t) 0), plus_code, iter_type, inner
 ? collapse->outer : collapse->base, fold_convert_loc (
((location_t) 0), plus_type, expr) )
	  fold_convert (plus_type, expr))fold_build2_loc (((location_t) 0), plus_code, iter_type, inner
 ? collapse->outer : collapse->base, fold_convert_loc (
((location_t) 0), plus_type, expr) );
    expr = force_gimple_operand_gsi (gsi, expr, false, NULL_TREE(tree) nullptr,
		       true, GSI_SAME_STMT);
    gassign *ass = gimple_build_assign (v, expr);
    gsi_insert_before (gsi, ass, GSI_SAME_STMT);
  }
1707}

1709/* Helper function for expand_omp_{for_*,simd}.  If this is the outermost
 of the combined collapse > 1 loop constructs, generate code like:
if (__builtin_expect (N32 cond3 N31, 0)) goto ZERO_ITER_BB;
if (cond3 is <)
 adj = STEP3 - 1;
else
 adj = STEP3 + 1;
count3 = (adj + N32 - N31) / STEP3;
if (__builtin_expect (N22 cond2 N21, 0)) goto ZERO_ITER_BB;
if (cond2 is <)
 adj = STEP2 - 1;
else
 adj = STEP2 + 1;
count2 = (adj + N22 - N21) / STEP2;
if (__builtin_expect (N12 cond1 N11, 0)) goto ZERO_ITER_BB;
if (cond1 is <)
 adj = STEP1 - 1;
else
 adj = STEP1 + 1;
count1 = (adj + N12 - N11) / STEP1;
count = count1 * count2 * count3;
 Furthermore, if ZERO_ITER_BB is NULL, create a BB which does:
count = 0;
 and set ZERO_ITER_BB to that bb.  If this isn't the outermost
 of the combined loop constructs, just initialize COUNTS array
 from the _looptemp_ clauses.  For loop nests with non-rectangular
 loops, do this only for the rectangular loops.  Then pick
 the loops which reference outer vars in their bound expressions
 and the loops which they refer to and for this sub-nest compute
 number of iterations.  For triangular loops use Faulhaber's formula,
 otherwise as a fallback, compute by iterating the loops.
 If e.g. the sub-nest is
for (I = N11; I COND1 N12; I += STEP1)
for (J = M21 * I + N21; J COND2 M22 * I + N22; J += STEP2)
for (K = M31 * J + N31; K COND3 M32 * J + N32; K += STEP3)
 do:
COUNT = 0;
for (tmpi = N11; tmpi COND1 N12; tmpi += STEP1)
for (tmpj = M21 * tmpi + N21;
    tmpj COND2 M22 * tmpi + N22; tmpj += STEP2)
 {
   int tmpk1 = M31 * tmpj + N31;
   int tmpk2 = M32 * tmpj + N32;
   if (tmpk1 COND3 tmpk2)
     {
if (COND3 is <)
  adj = STEP3 - 1;
else
  adj = STEP3 + 1;
COUNT += (adj + tmpk2 - tmpk1) / STEP3;
     }
 }
 and finally multiply the counts of the rectangular loops not
 in the sub-nest with COUNT.  Also, as counts[fd->last_nonrect]
 store number of iterations of the loops from fd->first_nonrect
 to fd->last_nonrect inclusive, i.e. the above COUNT multiplied
 by the counts of rectangular loops not referenced in any non-rectangular
 loops sandwitched in between those.  */

1768/* NOTE: It *could* be better to moosh all of the BBs together,
 creating one larger BB with all the computation and the unexpected
 jump at the end.  I.e.

 bool zero3, zero2, zero1, zero;

 zero3 = N32 c3 N31;
 count3 = (N32 - N31) /[cl] STEP3;
 zero2 = N22 c2 N21;
 count2 = (N22 - N21) /[cl] STEP2;
 zero1 = N12 c1 N11;
 count1 = (N12 - N11) /[cl] STEP1;
 zero = zero3 || zero2 || zero1;
 count = count1 * count2 * count3;
 if (__builtin_expect(zero, false)) goto zero_iter_bb;

 After all, we expect the zero=false, and thus we expect to have to
 evaluate all of the comparison expressions, so short-circuiting
 oughtn't be a win.  Since the condition isn't protecting a
 denominator, we're not concerned about divide-by-zero, so we can
 fully evaluate count even if a numerator turned out to be wrong.

 It seems like putting this all together would create much better
 scheduling opportunities, and less pressure on the chip's branch
 predictor.  */

1794static void
1795expand_omp_for_init_counts (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
	    basic_block &entry_bb, tree *counts,
	    basic_block &zero_iter1_bb, int &first_zero_iter1,
	    basic_block &zero_iter2_bb, int &first_zero_iter2,
	    basic_block &l2_dom_bb)
1800{
tree t, type = TREE_TYPE (fd->loop.v)((contains_struct_check ((fd->loop.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1801, __FUNCTION__))->typed.type);
edge e, ne;
int i;

/* Collapsed loops need work for expansion into SSA form.  */
gcc_assert (!gimple_in_ssa_p (cfun))((void)(!(!gimple_in_ssa_p ((cfun + 0))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1806, __FUNCTION__), 0 : 0));

if (gimple_omp_for_combined_into_p (fd->for_stmt)
    && TREE_CODE (fd->loop.n2)((enum tree_code) (fd->loop.n2)->base.code) != INTEGER_CST)
  {
    gcc_assert (fd->ordered == 0)((void)(!(fd->ordered == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1811, __FUNCTION__), 0 : 0));
    /* First two _looptemp_ clauses are for istart/iend, counts[0]
isn't supposed to be handled, as the inner loop doesn't
use it.  */
    tree innerc = omp_find_clause (gimple_omp_for_clauses (fd->for_stmt),
		     OMP_CLAUSE__LOOPTEMP_);
    gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1817, __FUNCTION__), 0 : 0));
    for (i = 0; i < fd->collapse; i++)
{
 innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1820, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1820, __FUNCTION__))->common.chain),
		    OMP_CLAUSE__LOOPTEMP_);
 gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1822, __FUNCTION__), 0 : 0));
 if (i)
   counts[i] = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1824, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1824, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1824, __FUNCTION__)));
 else
   counts[0] = NULL_TREE(tree) nullptr;
}
    if (fd->non_rect
 && fd->last_nonrect == fd->first_nonrect + 1
 && !TYPE_UNSIGNED (TREE_TYPE (fd->loops[fd->last_nonrect].v))((tree_class_check ((((contains_struct_check ((fd->loops[fd
->last_nonrect].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1830, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1830, __FUNCTION__))->base.u.bits.unsigned_flag))
{
 tree c[4];
 for (i = 0; i < 4; i++)
   {
     innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1835, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1835, __FUNCTION__))->common.chain),
			OMP_CLAUSE__LOOPTEMP_);
     gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1837, __FUNCTION__), 0 : 0));
     c[i] = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1838, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1838, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1838, __FUNCTION__)));
   }
 counts[0] = c[0];
 fd->first_inner_iterations = c[1];
 fd->factor = c[2];
 fd->adjn1 = c[3];
}
    return;
  }

for (i = fd->collapse; i < fd->ordered; i++)
  {
    tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1850, __FUNCTION__))->typed.type);
    counts[i] = NULL_TREE(tree) nullptr;
    t = fold_binary (fd->loops[i].cond_code, boolean_type_node,fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2))
       fold_convert (itype, fd->loops[i].n1),fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2))
       fold_convert (itype, fd->loops[i].n2))fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2));
    if (t && integer_zerop (t))
{
 for (i = fd->collapse; i < fd->ordered; i++)
   counts[i] = build_int_cst (type, 0);
 break;
}
  }
bool rect_count_seen = false;
for (i = 0; i < (fd->ordered ? fd->ordered : fd->collapse); i++)
  {
    tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1865, __FUNCTION__))->typed.type);

    if (i >= fd->collapse && counts[i])
continue;
    if (fd->non_rect)
{
 /* Skip loops that use outer iterators in their expressions
    during this phase.  */
 if (fd->loops[i].m1 || fd->loops[i].m2)
   {
     counts[i] = build_zero_cst (type);
     continue;
   }
}
    if ((SSA_VAR_P (fd->loop.n2)(((enum tree_code) (fd->loop.n2)->base.code) == VAR_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == PARM_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == RESULT_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == SSA_NAME
) || i >= fd->collapse)
 && ((t = fold_binary (fd->loops[i].cond_code, boolean_type_node,fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2))
		fold_convert (itype, fd->loops[i].n1),fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2))
		fold_convert (itype, fd->loops[i].n2))fold_binary_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), itype, fd->loops[i].n2)))
     == NULL_TREE(tree) nullptr || !integer_onep (t)))
{
 gcond *cond_stmt;
 tree n1, n2;
 n1 = fold_convert (itype, unshare_expr (fd->loops[i].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n1));
 n1 = force_gimple_operand_gsi (gsi, n1, true, NULL_TREE(tree) nullptr,
			 true, GSI_SAME_STMT);
 n2 = fold_convert (itype, unshare_expr (fd->loops[i].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n2));
 n2 = force_gimple_operand_gsi (gsi, n2, true, NULL_TREE(tree) nullptr,
			 true, GSI_SAME_STMT);
 cond_stmt = expand_omp_build_cond (gsi, fd->loops[i].cond_code,
			     n1, n2);
 e = split_block (entry_bb, cond_stmt);
 basic_block &zero_iter_bb
   = i < fd->collapse ? zero_iter1_bb : zero_iter2_bb;
 int &first_zero_iter
   = i < fd->collapse ? first_zero_iter1 : first_zero_iter2;
 if (zero_iter_bb == NULLnullptr)
   {
     gassign *assign_stmt;
     first_zero_iter = i;
     zero_iter_bb = create_empty_bb (entry_bb);
     add_bb_to_loop (zero_iter_bb, entry_bb->loop_father);
     *gsi = gsi_after_labels (zero_iter_bb);
     if (i < fd->collapse)
assign_stmt = gimple_build_assign (fd->loop.n2,
				   build_zero_cst (type));
     else
{
  counts[i] = create_tmp_reg (type, ".count");
  assign_stmt
    = gimple_build_assign (counts[i], build_zero_cst (type));
}
     gsi_insert_before (gsi, assign_stmt, GSI_SAME_STMT);
     set_immediate_dominator (CDI_DOMINATORS, zero_iter_bb,
		       entry_bb);
   }
 ne = make_edge (entry_bb, zero_iter_bb, EDGE_FALSE_VALUE);
 ne->probability = profile_probability::very_unlikely ();
 e->flags = EDGE_TRUE_VALUE;
 e->probability = ne->probability.invert ();
 if (l2_dom_bb == NULLnullptr)
   l2_dom_bb = entry_bb;
 entry_bb = e->dest;
 *gsi = gsi_last_nondebug_bb (entry_bb);
}

    if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
itype = signed_type_for (itype);
    t = build_int_cst (itype, (fd->loops[i].cond_code == LT_EXPR
		 ? -1 : 1));
    t = fold_build2 (PLUS_EXPR, itype,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step), t )
       fold_convert (itype, fd->loops[i].step), t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step), t );
    t = fold_build2 (PLUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].n2) )
       fold_convert (itype, fd->loops[i].n2))fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].n2) );
    t = fold_build2 (MINUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].n1) )
       fold_convert (itype, fd->loops[i].n1))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].n1) );
    /* ?? We could probably use CEIL_DIV_EXPR instead of
TRUNC_DIV_EXPR and adjusting by hand.  Unless we can't
generate the same code in the end because generically we
don't know that the values involved must be negative for
GT??  */
    if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1945, __FUNCTION__))->base.u.bits.unsigned_flag) && fd->loops[i].cond_code == GT_EXPR)
t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, fold_convert_loc (((location_t
) 0), itype, fd->loops[i].step) ) )
	 fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, fold_convert_loc (((location_t
) 0), itype, fd->loops[i].step) ) )
	 fold_build1 (NEGATE_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, fold_convert_loc (((location_t
) 0), itype, fd->loops[i].step) ) )
		      fold_convert (itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, fold_convert_loc (((location_t
) 0), itype, fd->loops[i].step) ) )
				    fd->loops[i].step)))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, fold_convert_loc (((location_t
) 0), itype, fd->loops[i].step) ) );
    else
t = fold_build2 (TRUNC_DIV_EXPR, itype, t,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) )
	 fold_convert (itype, fd->loops[i].step))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) );
    t = fold_convert (type, t)fold_convert_loc (((location_t) 0), type, t);
    if (TREE_CODE (t)((enum tree_code) (t)->base.code) == INTEGER_CST)
counts[i] = t;
    else
{
 if (i < fd->collapse || i != first_zero_iter2)
   counts[i] = create_tmp_reg (type, ".count");
 expand_omp_build_assign (gsi, counts[i], t);
}
    if (SSA_VAR_P (fd->loop.n2)(((enum tree_code) (fd->loop.n2)->base.code) == VAR_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == PARM_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == RESULT_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == SSA_NAME
) && i < fd->collapse)
{
 if (fd->non_rect && i >= fd->first_nonrect && i <= fd->last_nonrect)
   continue;
 if (!rect_count_seen)
   {
     t = counts[i];
     rect_count_seen = true;
   }
 else
   t = fold_build2 (MULT_EXPR, type, fd->loop.n2, counts[i])fold_build2_loc (((location_t) 0), MULT_EXPR, type, fd->loop
.n2, counts[i] );
 expand_omp_build_assign (gsi, fd->loop.n2, t);
}
  }
if (fd->non_rect && SSA_VAR_P (fd->loop.n2)(((enum tree_code) (fd->loop.n2)->base.code) == VAR_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == PARM_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == RESULT_DECL
 || ((enum tree_code) (fd->loop.n2)->base.code) == SSA_NAME
))
  {
    gcc_assert (fd->last_nonrect != -1)((void)(!(fd->last_nonrect != -1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1979, __FUNCTION__), 0 : 0));

    counts[fd->last_nonrect] = create_tmp_reg (type, ".count");
    expand_omp_build_assign (gsi, counts[fd->last_nonrect],
	       build_zero_cst (type));
    for (i = fd->first_nonrect + 1; i < fd->last_nonrect; i++)
if (fd->loops[i].m1
   || fd->loops[i].m2
   || fd->loops[i].non_rect_referenced)
 break;
    if (i == fd->last_nonrect
 && fd->loops[i].outer == fd->last_nonrect - fd->first_nonrect
 && !POINTER_TYPE_P (TREE_TYPE (fd->loops[i].v))(((enum tree_code) (((contains_struct_check ((fd->loops[i]
.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1991, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1991, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
 && !TYPE_UNSIGNED (TREE_TYPE (fd->loops[i].v))((tree_class_check ((((contains_struct_check ((fd->loops[i
].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1992, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1992, __FUNCTION__))->base.u.bits.unsigned_flag))
{
 int o = fd->first_nonrect;
 tree itype = TREE_TYPE (fd->loops[o].v)((contains_struct_check ((fd->loops[o].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 1995, __FUNCTION__))->typed.type);
 tree n1o = create_tmp_reg (itype, ".n1o");
 t = fold_convert (itype, unshare_expr (fd->loops[o].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[o].n1));
 expand_omp_build_assign (gsi, n1o, t);
 tree n2o = create_tmp_reg (itype, ".n2o");
 t = fold_convert (itype, unshare_expr (fd->loops[o].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[o].n2));
 expand_omp_build_assign (gsi, n2o, t);
 if (fd->loops[i].m1 && fd->loops[i].m2)
   t = fold_build2 (MINUS_EXPR, itype, unshare_expr (fd->loops[i].m2),fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, unshare_expr
 (fd->loops[i].m2), unshare_expr (fd->loops[i].m1) )
	     unshare_expr (fd->loops[i].m1))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, unshare_expr
 (fd->loops[i].m2), unshare_expr (fd->loops[i].m1) );
 else if (fd->loops[i].m1)
   t = fold_build1 (NEGATE_EXPR, itype,fold_build1_loc (((location_t) 0), NEGATE_EXPR, itype, unshare_expr
 (fd->loops[i].m1) )
	     unshare_expr (fd->loops[i].m1))fold_build1_loc (((location_t) 0), NEGATE_EXPR, itype, unshare_expr
 (fd->loops[i].m1) );
 else
   t = unshare_expr (fd->loops[i].m2);
 tree m2minusm1
   = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);

 gimple_stmt_iterator gsi2 = *gsi;
 gsi_prev (&gsi2);
 e = split_block (entry_bb, gsi_stmt (gsi2));
 e = split_block (e->dest, (gimple *) NULLnullptr);
 basic_block bb1 = e->src;
 entry_bb = e->dest;
 *gsi = gsi_after_labels (entry_bb);

 gsi2 = gsi_after_labels (bb1);
 tree ostep = fold_convert (itype, fd->loops[o].step)fold_convert_loc (((location_t) 0), itype, fd->loops[o].step
);
 t = build_int_cst (itype, (fd->loops[o].cond_code
		     == LT_EXPR ? -1 : 1));
 t = fold_build2 (PLUS_EXPR, itype, ostep, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, ostep, t
 );
 t = fold_build2 (PLUS_EXPR, itype, t, n2o)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, n2o );
 t = fold_build2 (MINUS_EXPR, itype, t, n1o)fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, n1o );
 if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2029, __FUNCTION__))->base.u.bits.unsigned_flag)
     && fd->loops[o].cond_code == GT_EXPR)
   t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, ostep ) )
	     fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, ostep ) )
	     fold_build1 (NEGATE_EXPR, itype, ostep))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, ostep ) );
 else
   t = fold_build2 (TRUNC_DIV_EXPR, itype, t, ostep)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, ostep
 );
 tree outer_niters
   = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);
 t = fold_build2 (MINUS_EXPR, itype, outer_niters,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, outer_niters
, build_one_cst (itype) )
	   build_one_cst (itype))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, outer_niters
, build_one_cst (itype) );
 t = fold_build2 (MULT_EXPR, itype, t, ostep)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, ostep
 );
 t = fold_build2 (PLUS_EXPR, itype, n1o, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1o, t );
 tree last = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
				true, GSI_SAME_STMT);
 tree n1, n2, n1e, n2e;
 t = fold_convert (itype, unshare_expr (fd->loops[i].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n1));
 if (fd->loops[i].m1)
   {
     n1 = fold_convert (itype, unshare_expr (fd->loops[i].m1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m1));
     n1 = fold_build2 (MULT_EXPR, itype, n1o, n1)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, n1o, n1 );
     n1 = fold_build2 (PLUS_EXPR, itype, n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1, t );
   }
 else
   n1 = t;
 n1 = force_gimple_operand_gsi (&gsi2, n1, true, NULL_TREE(tree) nullptr,
			 true, GSI_SAME_STMT);
 t = fold_convert (itype, unshare_expr (fd->loops[i].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n2));
 if (fd->loops[i].m2)
   {
     n2 = fold_convert (itype, unshare_expr (fd->loops[i].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m2));
     n2 = fold_build2 (MULT_EXPR, itype, n1o, n2)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, n1o, n2 );
     n2 = fold_build2 (PLUS_EXPR, itype, n2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n2, t );
   }
 else
   n2 = t;
 n2 = force_gimple_operand_gsi (&gsi2, n2, true, NULL_TREE(tree) nullptr,
			 true, GSI_SAME_STMT);
 t = fold_convert (itype, unshare_expr (fd->loops[i].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n1));
 if (fd->loops[i].m1)
   {
     n1e = fold_convert (itype, unshare_expr (fd->loops[i].m1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m1));
     n1e = fold_build2 (MULT_EXPR, itype, last, n1e)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, last, n1e
 );
     n1e = fold_build2 (PLUS_EXPR, itype, n1e, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1e, t );
   }
 else
   n1e = t;
 n1e = force_gimple_operand_gsi (&gsi2, n1e, true, NULL_TREE(tree) nullptr,
			  true, GSI_SAME_STMT);
 t = fold_convert (itype, unshare_expr (fd->loops[i].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n2));
 if (fd->loops[i].m2)
   {
     n2e = fold_convert (itype, unshare_expr (fd->loops[i].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m2));
     n2e = fold_build2 (MULT_EXPR, itype, last, n2e)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, last, n2e
 );
     n2e = fold_build2 (PLUS_EXPR, itype, n2e, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n2e, t );
   }
 else
   n2e = t;
 n2e = force_gimple_operand_gsi (&gsi2, n2e, true, NULL_TREE(tree) nullptr,
			  true, GSI_SAME_STMT);
 gcond *cond_stmt
   = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
		     n1, n2);
 e = split_block (bb1, cond_stmt);
 e->flags = EDGE_TRUE_VALUE;
 e->probability = profile_probability::likely ().guessed ();
 basic_block bb2 = e->dest;
 gsi2 = gsi_after_labels (bb2);

 cond_stmt = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
			     n1e, n2e);
 e = split_block (bb2, cond_stmt);
 e->flags = EDGE_TRUE_VALUE;
 e->probability = profile_probability::likely ().guessed ();
 gsi2 = gsi_after_labels (e->dest);

 tree step = fold_convert (itype, fd->loops[i].step)fold_convert_loc (((location_t) 0), itype, fd->loops[i].step
);
 t = build_int_cst (itype, (fd->loops[i].cond_code
		     == LT_EXPR ? -1 : 1));
 t = fold_build2 (PLUS_EXPR, itype, step, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, step, t );
 t = fold_build2 (PLUS_EXPR, itype, t, n2)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, n2 );
 t = fold_build2 (MINUS_EXPR, itype, t, n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, n1 );
 if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2112, __FUNCTION__))->base.u.bits.unsigned_flag)
     && fd->loops[i].cond_code == GT_EXPR)
   t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
	     fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
	     fold_build1 (NEGATE_EXPR, itype, step))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) );
 else
   t = fold_build2 (TRUNC_DIV_EXPR, itype, t, step)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, step
 );
 tree first_inner_iterations
   = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);
 t = fold_build2 (MULT_EXPR, itype, m2minusm1, ostep)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, m2minusm1
, ostep );
 if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2123, __FUNCTION__))->base.u.bits.unsigned_flag)
     && fd->loops[i].cond_code == GT_EXPR)
   t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
	     fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
	     fold_build1 (NEGATE_EXPR, itype, step))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) );
 else
   t = fold_build2 (TRUNC_DIV_EXPR, itype, t, step)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, step
 );
 tree factor
   = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);
 t = fold_build2 (MINUS_EXPR, itype, outer_niters,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, outer_niters
, build_one_cst (itype) )
	   build_one_cst (itype))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, outer_niters
, build_one_cst (itype) );
 t = fold_build2 (MULT_EXPR, itype, t, outer_niters)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, outer_niters
 );
 t = fold_build2 (RSHIFT_EXPR, itype, t, integer_one_node)fold_build2_loc (((location_t) 0), RSHIFT_EXPR, itype, t, global_trees
[TI_INTEGER_ONE] );
 t = fold_build2 (MULT_EXPR, itype, factor, t)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, factor, t
 );
 t = fold_build2 (PLUS_EXPR, itype,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_build2_loc
 (((location_t) 0), MULT_EXPR, itype, outer_niters, first_inner_iterations
 ), t )
	   fold_build2 (MULT_EXPR, itype, outer_niters,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_build2_loc
 (((location_t) 0), MULT_EXPR, itype, outer_niters, first_inner_iterations
 ), t )
			first_inner_iterations), t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_build2_loc
 (((location_t) 0), MULT_EXPR, itype, outer_niters, first_inner_iterations
 ), t );
 expand_omp_build_assign (&gsi2, counts[fd->last_nonrect],
		   fold_convert (type, t)fold_convert_loc (((location_t) 0), type, t));

 basic_block bb3 = create_empty_bb (bb1);
 add_bb_to_loop (bb3, bb1->loop_father);

 e = make_edge (bb1, bb3, EDGE_FALSE_VALUE);
 e->probability = profile_probability::unlikely ().guessed ();

 gsi2 = gsi_after_labels (bb3);
 cond_stmt = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
			     n1e, n2e);
 e = split_block (bb3, cond_stmt);
 e->flags = EDGE_TRUE_VALUE;
 e->probability = profile_probability::likely ().guessed ();
 basic_block bb4 = e->dest;

 ne = make_edge (bb3, entry_bb, EDGE_FALSE_VALUE);
 ne->probability = e->probability.invert ();

 basic_block bb5 = create_empty_bb (bb2);
 add_bb_to_loop (bb5, bb2->loop_father);

 ne = make_edge (bb2, bb5, EDGE_FALSE_VALUE);
 ne->probability = profile_probability::unlikely ().guessed ();

 for (int j = 0; j < 2; j++)
   {
     gsi2 = gsi_after_labels (j ? bb5 : bb4);
     t = fold_build2 (MINUS_EXPR, itype,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, unshare_expr
 (fd->loops[i].n1), unshare_expr (fd->loops[i].n2) )
	       unshare_expr (fd->loops[i].n1),fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, unshare_expr
 (fd->loops[i].n1), unshare_expr (fd->loops[i].n2) )
	       unshare_expr (fd->loops[i].n2))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, unshare_expr
 (fd->loops[i].n1), unshare_expr (fd->loops[i].n2) );
     t = fold_build2 (TRUNC_DIV_EXPR, itype, t, m2minusm1)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, m2minusm1
 );
     tree tem
= force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			    true, GSI_SAME_STMT);
     t = fold_build2 (MINUS_EXPR, itype, tem, n1o)fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, tem, n1o
 );
     t = fold_build2 (TRUNC_MOD_EXPR, itype, t, ostep)fold_build2_loc (((location_t) 0), TRUNC_MOD_EXPR, itype, t, ostep
 );
     t = fold_build2 (MINUS_EXPR, itype, tem, t)fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, tem, t );
     tem = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			      true, GSI_SAME_STMT);
     t = fold_convert (itype, unshare_expr (fd->loops[i].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n1));
     if (fd->loops[i].m1)
{
  n1 = fold_convert (itype, unshare_expr (fd->loops[i].m1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m1));
  n1 = fold_build2 (MULT_EXPR, itype, tem, n1)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, tem, n1 );
  n1 = fold_build2 (PLUS_EXPR, itype, n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1, t );
}
     else
n1 = t;
     n1 = force_gimple_operand_gsi (&gsi2, n1, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     t = fold_convert (itype, unshare_expr (fd->loops[i].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n2));
     if (fd->loops[i].m2)
{
  n2 = fold_convert (itype, unshare_expr (fd->loops[i].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m2));
  n2 = fold_build2 (MULT_EXPR, itype, tem, n2)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, tem, n2 );
  n2 = fold_build2 (PLUS_EXPR, itype, n2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n2, t );
}
     else
n2 = t;
     n2 = force_gimple_operand_gsi (&gsi2, n2, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     expand_omp_build_assign (&gsi2, j ? n2o : n1o, tem);

     cond_stmt = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
				 n1, n2);
     e = split_block (gsi_bb (gsi2), cond_stmt);
     e->flags = j ? EDGE_TRUE_VALUE : EDGE_FALSE_VALUE;
     e->probability = profile_probability::unlikely ().guessed ();
     ne = make_edge (e->src, bb1,
	      j ? EDGE_FALSE_VALUE : EDGE_TRUE_VALUE);
     ne->probability = e->probability.invert ();
     gsi2 = gsi_after_labels (e->dest);

     t = fold_build2 (PLUS_EXPR, itype, tem, ostep)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, tem, ostep
 );
     expand_omp_build_assign (&gsi2, j ? n2o : n1o, t);

     make_edge (e->dest, bb1, EDGE_FALLTHRU);
   }

 set_immediate_dominator (CDI_DOMINATORS, bb3, bb1);
 set_immediate_dominator (CDI_DOMINATORS, bb5, bb2);
 set_immediate_dominator (CDI_DOMINATORS, entry_bb, bb1);

 if (fd->first_nonrect + 1 == fd->last_nonrect)
   {
     fd->first_inner_iterations = first_inner_iterations;
     fd->factor = factor;
     fd->adjn1 = n1o;
   }
}
    else
{
 /* Fallback implementation.  Evaluate the loops with m1/m2
    non-NULL as well as their outer loops at runtime using temporaries
    instead of the original iteration variables, and in the
    body just bump the counter.  */
 gimple_stmt_iterator gsi2 = *gsi;
 gsi_prev (&gsi2);
 e = split_block (entry_bb, gsi_stmt (gsi2));
 e = split_block (e->dest, (gimple *) NULLnullptr);
 basic_block cur_bb = e->src;
 basic_block next_bb = e->dest;
 entry_bb = e->dest;
 *gsi = gsi_after_labels (entry_bb);

 tree *vs = XALLOCAVEC (tree, fd->last_nonrect)((tree *) __builtin_alloca(sizeof (tree) * (fd->last_nonrect
)));
 memset (vs, 0, fd->last_nonrect * sizeof (tree));

 for (i = 0; i <= fd->last_nonrect; i++)
   {
     if (fd->loops[i].m1 == NULL_TREE(tree) nullptr
  && fd->loops[i].m2 == NULL_TREE(tree) nullptr
  && !fd->loops[i].non_rect_referenced)
continue;

     tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2258, __FUNCTION__))->typed.type);

     gsi2 = gsi_after_labels (cur_bb);
     tree n1, n2;
     t = fold_convert (itype, unshare_expr (fd->loops[i].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n1));
     if (fd->loops[i].m1 == NULL_TREE(tree) nullptr)
n1 = t;
     else if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
{
  gcc_assert (integer_onep (fd->loops[i].m1))((void)(!(integer_onep (fd->loops[i].m1)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2267, __FUNCTION__), 0 : 0));
  t = unshare_expr (fd->loops[i].n1);
  n1 = fold_build_pointer_plus (vs[i - fd->loops[i].outer], t)fold_build_pointer_plus_loc (((location_t) 0), vs[i - fd->
loops[i].outer], t);
}
     else
{
  n1 = fold_convert (itype, unshare_expr (fd->loops[i].m1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m1));
  n1 = fold_build2 (MULT_EXPR, itype,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[i - fd
->loops[i].outer], n1 )
		    vs[i - fd->loops[i].outer], n1)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[i - fd
->loops[i].outer], n1 );
  n1 = fold_build2 (PLUS_EXPR, itype, n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1, t );
}
     n1 = force_gimple_operand_gsi (&gsi2, n1, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     if (i < fd->last_nonrect)
{
  vs[i] = create_tmp_reg (itype, ".it");
  expand_omp_build_assign (&gsi2, vs[i], n1);
}
     t = fold_convert (itype, unshare_expr (fd->loops[i].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].n2));
     if (fd->loops[i].m2 == NULL_TREE(tree) nullptr)
n2 = t;
     else if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
{
  gcc_assert (integer_onep (fd->loops[i].m2))((void)(!(integer_onep (fd->loops[i].m2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2290, __FUNCTION__), 0 : 0));
  t = unshare_expr (fd->loops[i].n2);
  n2 = fold_build_pointer_plus (vs[i - fd->loops[i].outer], t)fold_build_pointer_plus_loc (((location_t) 0), vs[i - fd->
loops[i].outer], t);
}
     else
{
  n2 = fold_convert (itype, unshare_expr (fd->loops[i].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m2));
  n2 = fold_build2 (MULT_EXPR, itype,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[i - fd
->loops[i].outer], n2 )
		    vs[i - fd->loops[i].outer], n2)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[i - fd
->loops[i].outer], n2 );
  n2 = fold_build2 (PLUS_EXPR, itype, n2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n2, t );
}
     n2 = force_gimple_operand_gsi (&gsi2, n2, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
itype = signed_type_for (itype);
     if (i == fd->last_nonrect)
{
  gcond *cond_stmt
    = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
			     n1, n2);
  e = split_block (cur_bb, cond_stmt);
  e->flags = EDGE_TRUE_VALUE;
  ne = make_edge (cur_bb, next_bb, EDGE_FALSE_VALUE);
  e->probability = profile_probability::likely ().guessed ();
  ne->probability = e->probability.invert ();
  gsi2 = gsi_after_labels (e->dest);

  t = build_int_cst (itype, (fd->loops[i].cond_code == LT_EXPR
			     ? -1 : 1));
  t = fold_build2 (PLUS_EXPR, itype,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step), t )
		   fold_convert (itype, fd->loops[i].step), t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step), t );
  t = fold_build2 (PLUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n2) )
		   fold_convert (itype, n2))fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n2) );
  t = fold_build2 (MINUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n1) )
		   fold_convert (itype, n1))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n1) );
  tree step = fold_convert (itype, fd->loops[i].step)fold_convert_loc (((location_t) 0), itype, fd->loops[i].step
);
  if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2326, __FUNCTION__))->base.u.bits.unsigned_flag)
      && fd->loops[i].cond_code == GT_EXPR)
    t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
		     fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
		     fold_build1 (NEGATE_EXPR, itype, step))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) );
  else
    t = fold_build2 (TRUNC_DIV_EXPR, itype, t, step)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, step
 );
  t = fold_convert (type, t)fold_convert_loc (((location_t) 0), type, t);
  t = fold_build2 (PLUS_EXPR, type,fold_build2_loc (((location_t) 0), PLUS_EXPR, type, counts[fd
->last_nonrect], t )
		   counts[fd->last_nonrect], t)fold_build2_loc (((location_t) 0), PLUS_EXPR, type, counts[fd
->last_nonrect], t );
  t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
				true, GSI_SAME_STMT);
  expand_omp_build_assign (&gsi2, counts[fd->last_nonrect], t);
  e = make_edge (e->dest, next_bb, EDGE_FALLTHRU);
  set_immediate_dominator (CDI_DOMINATORS, next_bb, cur_bb);
  break;
}
     e = split_block (cur_bb, last_stmt (cur_bb));

     basic_block new_cur_bb = create_empty_bb (cur_bb);
     add_bb_to_loop (new_cur_bb, cur_bb->loop_father);

     gsi2 = gsi_after_labels (e->dest);
     tree step = fold_convert (itype,fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].step))
			unshare_expr (fd->loops[i].step))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].step));
     if (POINTER_TYPE_P (TREE_TYPE (vs[i]))(((enum tree_code) (((contains_struct_check ((vs[i]), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2351, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((vs[i]), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2351, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
t = fold_build_pointer_plus (vs[i], step)fold_build_pointer_plus_loc (((location_t) 0), vs[i], step);
     else
t = fold_build2 (PLUS_EXPR, itype, vs[i], step)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, vs[i], step
 );
     t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			    true, GSI_SAME_STMT);
     expand_omp_build_assign (&gsi2, vs[i], t);

     ne = split_block (e->dest, last_stmt (e->dest));
     gsi2 = gsi_after_labels (ne->dest);

     expand_omp_build_cond (&gsi2, fd->loops[i].cond_code, vs[i], n2);
     edge e3, e4;
     if (next_bb == entry_bb)
{
  e3 = find_edge (ne->dest, next_bb);
  e3->flags = EDGE_FALSE_VALUE;
}
     else
e3 = make_edge (ne->dest, next_bb, EDGE_FALSE_VALUE);
     e4 = make_edge (ne->dest, new_cur_bb, EDGE_TRUE_VALUE);
     e4->probability = profile_probability::likely ().guessed ();
     e3->probability = e4->probability.invert ();
     basic_block esrc = e->src;
     make_edge (e->src, ne->dest, EDGE_FALLTHRU);
     cur_bb = new_cur_bb;
     basic_block latch_bb = next_bb;
     next_bb = e->dest;
     remove_edge (e);
     set_immediate_dominator (CDI_DOMINATORS, ne->dest, esrc);
     set_immediate_dominator (CDI_DOMINATORS, latch_bb, ne->dest);
     set_immediate_dominator (CDI_DOMINATORS, cur_bb, ne->dest);
   }
}
    t = NULL_TREE(tree) nullptr;
    for (i = fd->first_nonrect; i < fd->last_nonrect; i++)
if (!fd->loops[i].non_rect_referenced
   && fd->loops[i].m1 == NULL_TREE(tree) nullptr
   && fd->loops[i].m2 == NULL_TREE(tree) nullptr)
 {
   if (t == NULL_TREE(tree) nullptr)
     t = counts[i];
   else
     t = fold_build2 (MULT_EXPR, type, t, counts[i])fold_build2_loc (((location_t) 0), MULT_EXPR, type, t, counts
[i] );
 }
    if (t)
{
 t = fold_build2 (MULT_EXPR, type, counts[fd->last_nonrect], t)fold_build2_loc (((location_t) 0), MULT_EXPR, type, counts[fd
->last_nonrect], t );
 expand_omp_build_assign (gsi, counts[fd->last_nonrect], t);
}
    if (!rect_count_seen)
t = counts[fd->last_nonrect];
    else
t = fold_build2 (MULT_EXPR, type, fd->loop.n2,fold_build2_loc (((location_t) 0), MULT_EXPR, type, fd->loop
.n2, counts[fd->last_nonrect] )
	 counts[fd->last_nonrect])fold_build2_loc (((location_t) 0), MULT_EXPR, type, fd->loop
.n2, counts[fd->last_nonrect] );
    expand_omp_build_assign (gsi, fd->loop.n2, t);
  }
else if (fd->non_rect)
  {
    tree t = fd->loop.n2;
    gcc_assert (TREE_CODE (t) == INTEGER_CST)((void)(!(((enum tree_code) (t)->base.code) == INTEGER_CST
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2411, __FUNCTION__), 0 : 0));
    int non_rect_referenced = 0, non_rect = 0;
    for (i = 0; i < fd->collapse; i++)
{
 if ((i < fd->first_nonrect || i > fd->last_nonrect)
     && !integer_zerop (counts[i]))
   t = fold_build2 (TRUNC_DIV_EXPR, type, t, counts[i])fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, type, t, counts
[i] );
 if (fd->loops[i].non_rect_referenced)
   non_rect_referenced++;
 if (fd->loops[i].m1 || fd->loops[i].m2)
   non_rect++;
}
    gcc_assert (non_rect == 1 && non_rect_referenced == 1)((void)(!(non_rect == 1 && non_rect_referenced == 1) ?
 fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2423, __FUNCTION__), 0 : 0));
    counts[fd->last_nonrect] = t;
  }
2426}

2428/* Helper function for expand_omp_{for_*,simd}.  Generate code like:
T = V;
V3 = N31 + (T % count3) * STEP3;
T = T / count3;
V2 = N21 + (T % count2) * STEP2;
T = T / count2;
V1 = N11 + T * STEP1;
 if this loop doesn't have an inner loop construct combined with it.
 If it does have an inner loop construct combined with it and the
 iteration count isn't known constant, store values from counts array
 into its _looptemp_ temporaries instead.
 For non-rectangular loops (between fd->first_nonrect and fd->last_nonrect
 inclusive), use the count of all those loops together, and either
 find quadratic etc. equation roots, or as a fallback, do:
COUNT = 0;
for (tmpi = N11; tmpi COND1 N12; tmpi += STEP1)
for (tmpj = M21 * tmpi + N21;
    tmpj COND2 M22 * tmpi + N22; tmpj += STEP2)
 {
   int tmpk1 = M31 * tmpj + N31;
   int tmpk2 = M32 * tmpj + N32;
   if (tmpk1 COND3 tmpk2)
     {
if (COND3 is <)
  adj = STEP3 - 1;
else
  adj = STEP3 + 1;
int temp = (adj + tmpk2 - tmpk1) / STEP3;
if (COUNT + temp > T)
  {
    V1 = tmpi;
    V2 = tmpj;
    V3 = tmpk1 + (T - COUNT) * STEP3;
    goto done;
  }
else
  COUNT += temp;
     }
 }
done:;
 but for optional innermost or outermost rectangular loops that aren't
 referenced by other loop expressions keep doing the division/modulo.  */

2471static void
2472expand_omp_for_init_vars (struct omp_for_data *fd, gimple_stmt_iterator *gsi,
	  tree *counts, tree *nonrect_bounds,
	  gimple *inner_stmt, tree startvar)
2475{
int i;
if (gimple_omp_for_combined_p (fd->for_stmt))
  {
    /* If fd->loop.n2 is constant, then no propagation of the counts
is needed, they are constant.  */
    if (TREE_CODE (fd->loop.n2)((enum tree_code) (fd->loop.n2)->base.code) == INTEGER_CST)
return;

    tree clauses = gimple_code (inner_stmt) != GIMPLE_OMP_FOR
     ? gimple_omp_taskreg_clauses (inner_stmt)
     : gimple_omp_for_clauses (inner_stmt);
    /* First two _looptemp_ clauses are for istart/iend, counts[0]
isn't supposed to be handled, as the inner loop doesn't
use it.  */
    tree innerc = omp_find_clause (clauses, OMP_CLAUSE__LOOPTEMP_);
    gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2491, __FUNCTION__), 0 : 0));
    int count = 0;
    if (fd->non_rect
 && fd->last_nonrect == fd->first_nonrect + 1
 && !TYPE_UNSIGNED (TREE_TYPE (fd->loops[fd->last_nonrect].v))((tree_class_check ((((contains_struct_check ((fd->loops[fd
->last_nonrect].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2495, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2495, __FUNCTION__))->base.u.bits.unsigned_flag))
count = 4;
    for (i = 0; i < fd->collapse + count; i++)
{
 innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2499, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2499, __FUNCTION__))->common.chain),
		    OMP_CLAUSE__LOOPTEMP_);
 gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2501, __FUNCTION__), 0 : 0));
 if (i)
   {
     tree tem = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2504, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2504, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2504, __FUNCTION__)));
     tree t;
     if (i < fd->collapse)
t = counts[i];
     else
switch (i - fd->collapse)
  {
  case 0: t = counts[0]; break;
  case 1: t = fd->first_inner_iterations; break;
  case 2: t = fd->factor; break;
  case 3: t = fd->adjn1; break;
  default: gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2515, __FUNCTION__));
  }
     t = fold_convert (TREE_TYPE (tem), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(tem), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2517, __FUNCTION__))->typed.type), t);
     t = force_gimple_operand_gsi (gsi, t, false, NULL_TREE(tree) nullptr,
			    false, GSI_CONTINUE_LINKING);
     gassign *stmt = gimple_build_assign (tem, t);
     gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
   }
}
    return;
  }

tree type = TREE_TYPE (fd->loop.v)((contains_struct_check ((fd->loop.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2527, __FUNCTION__))->typed.type);
tree tem = create_tmp_reg (type, ".tem");
gassign *stmt = gimple_build_assign (tem, startvar);
gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);

for (i = fd->collapse - 1; i >= 0; i--)
  {
    tree vtype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2534, __FUNCTION__))->typed.type), itype, t;
    itype = vtype;
    if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
itype = signed_type_for (vtype);
    if (i != 0 && (i != fd->last_nonrect || fd->first_nonrect))
t = fold_build2 (TRUNC_MOD_EXPR, type, tem, counts[i])fold_build2_loc (((location_t) 0), TRUNC_MOD_EXPR, type, tem,
 counts[i] );
    else
t = tem;
    if (i == fd->last_nonrect)
{
 t = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr,
			false, GSI_CONTINUE_LINKING);
 tree stopval = t;
 tree idx = create_tmp_reg (type, ".count");
 expand_omp_build_assign (gsi, idx,
		   build_zero_cst (type), true);
 basic_block bb_triang = NULLnullptr, bb_triang_dom = NULLnullptr;
 if (fd->first_nonrect + 1 == fd->last_nonrect
     && (TREE_CODE (fd->loop.n2)((enum tree_code) (fd->loop.n2)->base.code) == INTEGER_CST
  || fd->first_inner_iterations)
     && (optab_handler (sqrt_optab, TYPE_MODE (double_type_node)((((enum tree_code) ((tree_class_check ((global_trees[TI_DOUBLE_TYPE
]), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2554, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (global_trees[TI_DOUBLE_TYPE]) : (global_trees[TI_DOUBLE_TYPE
])->type_common.mode))
  != CODE_FOR_nothing)
     && !integer_zerop (fd->loop.n2))
   {
     tree outer_n1 = fd->adjn1 ? fd->adjn1 : fd->loops[i - 1].n1;
     tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2559, __FUNCTION__))->typed.type);
     tree first_inner_iterations = fd->first_inner_iterations;
     tree factor = fd->factor;
     gcond *cond_stmt
= expand_omp_build_cond (gsi, NE_EXPR, factor,
			 build_zero_cst (TREE_TYPE (factor)((contains_struct_check ((factor), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2564, __FUNCTION__))->typed.type)));
     edge e = split_block (gsi_bb (*gsi), cond_stmt);
     basic_block bb0 = e->src;
     e->flags = EDGE_TRUE_VALUE;
     e->probability = profile_probability::likely ();
     bb_triang_dom = bb0;
     *gsi = gsi_after_labels (e->dest);
     tree slltype = long_long_integer_type_nodeinteger_types[itk_long_long];
     tree ulltype = long_long_unsigned_type_nodeinteger_types[itk_unsigned_long_long];
     tree stopvalull = fold_convert (ulltype, stopval)fold_convert_loc (((location_t) 0), ulltype, stopval);
     stopvalull
= force_gimple_operand_gsi (gsi, stopvalull, true, NULL_TREE(tree) nullptr,
			    false, GSI_CONTINUE_LINKING);
     first_inner_iterations
= fold_convert (slltype, first_inner_iterations)fold_convert_loc (((location_t) 0), slltype, first_inner_iterations
);
     first_inner_iterations
= force_gimple_operand_gsi (gsi, first_inner_iterations, true,
			    NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     factor = fold_convert (slltype, factor)fold_convert_loc (((location_t) 0), slltype, factor);
     factor
= force_gimple_operand_gsi (gsi, factor, true, NULL_TREE(tree) nullptr,
			    false, GSI_CONTINUE_LINKING);
     tree first_inner_iterationsd
= fold_build1 (FLOAT_EXPR, double_type_node,fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], first_inner_iterations )
	       first_inner_iterations)fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], first_inner_iterations );
     first_inner_iterationsd
= force_gimple_operand_gsi (gsi, first_inner_iterationsd, true,
			    NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     tree factord = fold_build1 (FLOAT_EXPR, double_type_node,fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], factor )
			  factor)fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], factor );
     factord = force_gimple_operand_gsi (gsi, factord, true,
				  NULL_TREE(tree) nullptr, false,
				  GSI_CONTINUE_LINKING);
     tree stopvald = fold_build1 (FLOAT_EXPR, double_type_node,fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], stopvalull )
			   stopvalull)fold_build1_loc (((location_t) 0), FLOAT_EXPR, global_trees[TI_DOUBLE_TYPE
], stopvalull );
     stopvald = force_gimple_operand_gsi (gsi, stopvald, true,
				   NULL_TREE(tree) nullptr, false,
				   GSI_CONTINUE_LINKING);
     /* Temporarily disable flag_rounding_math, values will be
 decimal numbers divided by 2 and worst case imprecisions
 due to too large values ought to be caught later by the
 checks for fallback.  */
     int save_flag_rounding_math = flag_rounding_mathglobal_options.x_flag_rounding_math;
     flag_rounding_mathglobal_options.x_flag_rounding_math = 0;
     t = fold_build2 (RDIV_EXPR, double_type_node, factord,fold_build2_loc (((location_t) 0), RDIV_EXPR, global_trees[TI_DOUBLE_TYPE
], factord, build_real (global_trees[TI_DOUBLE_TYPE], dconst2
) )
	       build_real (double_type_node, dconst2))fold_build2_loc (((location_t) 0), RDIV_EXPR, global_trees[TI_DOUBLE_TYPE
], factord, build_real (global_trees[TI_DOUBLE_TYPE], dconst2
) );
     tree t3 = fold_build2 (MINUS_EXPR, double_type_node,fold_build2_loc (((location_t) 0), MINUS_EXPR, global_trees[TI_DOUBLE_TYPE
], first_inner_iterationsd, t )
		     first_inner_iterationsd, t)fold_build2_loc (((location_t) 0), MINUS_EXPR, global_trees[TI_DOUBLE_TYPE
], first_inner_iterationsd, t );
     t3 = force_gimple_operand_gsi (gsi, t3, true, NULL_TREE(tree) nullptr, false,
			     GSI_CONTINUE_LINKING);
     t = fold_build2 (MULT_EXPR, double_type_node, factord,fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees[TI_DOUBLE_TYPE
], factord, build_real (global_trees[TI_DOUBLE_TYPE], dconst2
) )
	       build_real (double_type_node, dconst2))fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees[TI_DOUBLE_TYPE
], factord, build_real (global_trees[TI_DOUBLE_TYPE], dconst2
) );
     t = fold_build2 (MULT_EXPR, double_type_node, t, stopvald)fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees[TI_DOUBLE_TYPE
], t, stopvald );
     t = fold_build2 (PLUS_EXPR, double_type_node, t,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_DOUBLE_TYPE
], t, fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees
[TI_DOUBLE_TYPE], t3, t3 ) )
	       fold_build2 (MULT_EXPR, double_type_node,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_DOUBLE_TYPE
], t, fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees
[TI_DOUBLE_TYPE], t3, t3 ) )
			    t3, t3))fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_DOUBLE_TYPE
], t, fold_build2_loc (((location_t) 0), MULT_EXPR, global_trees
[TI_DOUBLE_TYPE], t3, t3 ) );
     flag_rounding_mathglobal_options.x_flag_rounding_math = save_flag_rounding_math;
     t = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     if (flag_exceptionsglobal_options.x_flag_exceptions
  && cfun(cfun + 0)->can_throw_non_call_exceptions
  && operation_could_trap_p (LT_EXPR, true, false, NULL_TREE(tree) nullptr))
{
  tree tem = fold_build2 (LT_EXPR, boolean_type_node, t,fold_build2_loc (((location_t) 0), LT_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_zero_cst (global_trees[TI_DOUBLE_TYPE]) )
			  build_zero_cst (double_type_node))fold_build2_loc (((location_t) 0), LT_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_zero_cst (global_trees[TI_DOUBLE_TYPE]) );
  tem = force_gimple_operand_gsi (gsi, tem, true, NULL_TREE(tree) nullptr,
				  false, GSI_CONTINUE_LINKING);
  cond_stmt = gimple_build_cond (NE_EXPR, tem,
				 boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE],
				 NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
}
     else
cond_stmt
  = gimple_build_cond (LT_EXPR, t,
		       build_zero_cst (double_type_nodeglobal_trees[TI_DOUBLE_TYPE]),
		       NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     gsi_insert_after (gsi, cond_stmt, GSI_CONTINUE_LINKING);
     e = split_block (gsi_bb (*gsi), cond_stmt);
     basic_block bb1 = e->src;
     e->flags = EDGE_FALSE_VALUE;
     e->probability = profile_probability::very_likely ();
     *gsi = gsi_after_labels (e->dest);
     gcall *call = gimple_build_call_internal (IFN_SQRT, 1, t);
     tree sqrtr = create_tmp_var (double_type_nodeglobal_trees[TI_DOUBLE_TYPE]);
     gimple_call_set_lhs (call, sqrtr);
     gsi_insert_after (gsi, call, GSI_CONTINUE_LINKING);
     t = fold_build2 (MINUS_EXPR, double_type_node, sqrtr, t3)fold_build2_loc (((location_t) 0), MINUS_EXPR, global_trees[TI_DOUBLE_TYPE
], sqrtr, t3 );
     t = fold_build2 (RDIV_EXPR, double_type_node, t, factord)fold_build2_loc (((location_t) 0), RDIV_EXPR, global_trees[TI_DOUBLE_TYPE
], t, factord );
     t = fold_build1 (FIX_TRUNC_EXPR, ulltype, t)fold_build1_loc (((location_t) 0), FIX_TRUNC_EXPR, ulltype, t
 );
     tree c = create_tmp_var (ulltype);
     tree d = create_tmp_var (ulltype);
     expand_omp_build_assign (gsi, c, t, true);
     t = fold_build2 (MINUS_EXPR, ulltype, c,fold_build2_loc (((location_t) 0), MINUS_EXPR, ulltype, c, build_one_cst
 (ulltype) )
	       build_one_cst (ulltype))fold_build2_loc (((location_t) 0), MINUS_EXPR, ulltype, c, build_one_cst
 (ulltype) );
     t = fold_build2 (MULT_EXPR, ulltype, c, t)fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, c, t );
     t = fold_build2 (RSHIFT_EXPR, ulltype, t, integer_one_node)fold_build2_loc (((location_t) 0), RSHIFT_EXPR, ulltype, t, global_trees
[TI_INTEGER_ONE] );
     t = fold_build2 (MULT_EXPR, ulltype,fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, fold_convert_loc
 (((location_t) 0), ulltype, fd->factor), t )
	       fold_convert (ulltype, fd->factor), t)fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, fold_convert_loc
 (((location_t) 0), ulltype, fd->factor), t );
     tree t2
= fold_build2 (MULT_EXPR, ulltype, c,fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, c, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) )
	       fold_convert (ulltype,fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, c, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) )
			     fd->first_inner_iterations))fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, c, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) );
     t = fold_build2 (PLUS_EXPR, ulltype, t, t2)fold_build2_loc (((location_t) 0), PLUS_EXPR, ulltype, t, t2 );
     expand_omp_build_assign (gsi, d, t, true);
     t = fold_build2 (MULT_EXPR, ulltype,fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, fold_convert_loc
 (((location_t) 0), ulltype, fd->factor), c )
	       fold_convert (ulltype, fd->factor), c)fold_build2_loc (((location_t) 0), MULT_EXPR, ulltype, fold_convert_loc
 (((location_t) 0), ulltype, fd->factor), c );
     t = fold_build2 (PLUS_EXPR, ulltype,fold_build2_loc (((location_t) 0), PLUS_EXPR, ulltype, t, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) )
	       t, fold_convert (ulltype,fold_build2_loc (((location_t) 0), PLUS_EXPR, ulltype, t, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) )
				fd->first_inner_iterations))fold_build2_loc (((location_t) 0), PLUS_EXPR, ulltype, t, fold_convert_loc
 (((location_t) 0), ulltype, fd->first_inner_iterations) );
     t2 = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr, false,
			     GSI_CONTINUE_LINKING);
     cond_stmt = gimple_build_cond (GE_EXPR, stopvalull, d,
			     NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     gsi_insert_after (gsi, cond_stmt, GSI_CONTINUE_LINKING);
     e = split_block (gsi_bb (*gsi), cond_stmt);
     basic_block bb2 = e->src;
     e->flags = EDGE_TRUE_VALUE;
     e->probability = profile_probability::very_likely ();
     *gsi = gsi_after_labels (e->dest);
     t = fold_build2 (PLUS_EXPR, ulltype, d, t2)fold_build2_loc (((location_t) 0), PLUS_EXPR, ulltype, d, t2 );
     t = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     cond_stmt = gimple_build_cond (GE_EXPR, stopvalull, t,
			     NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     gsi_insert_after (gsi, cond_stmt, GSI_CONTINUE_LINKING);
     e = split_block (gsi_bb (*gsi), cond_stmt);
     basic_block bb3 = e->src;
     e->flags = EDGE_FALSE_VALUE;
     e->probability = profile_probability::very_likely ();
     *gsi = gsi_after_labels (e->dest);
     t = fold_convert (itype, c)fold_convert_loc (((location_t) 0), itype, c);
     t = fold_build2 (MULT_EXPR, itype, t, fd->loops[i - 1].step)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fd->
loops[i - 1].step );
     t = fold_build2 (PLUS_EXPR, itype, outer_n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, outer_n1
, t );
     t = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     expand_omp_build_assign (gsi, fd->loops[i - 1].v, t, true);
     t2 = fold_build2 (MINUS_EXPR, ulltype, stopvalull, d)fold_build2_loc (((location_t) 0), MINUS_EXPR, ulltype, stopvalull
, d );
     t2 = fold_convert (itype, t2)fold_convert_loc (((location_t) 0), itype, t2);
     t2 = fold_build2 (MULT_EXPR, itype, t2, fd->loops[i].step)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t2, fd->
loops[i].step );
     t2 = fold_build2 (PLUS_EXPR, itype, t2, fd->loops[i].n1)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t2, fd->
loops[i].n1 );
     if (fd->loops[i].m1)
{
  t = fold_build2 (MULT_EXPR, itype, t, fd->loops[i].m1)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fd->
loops[i].m1 );
  t2 = fold_build2 (PLUS_EXPR, itype, t2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t2, t );
}
     expand_omp_build_assign (gsi, fd->loops[i].v, t2, true);
     e = split_block (gsi_bb (*gsi), gsi_stmt (*gsi));
     bb_triang = e->src;
     *gsi = gsi_after_labels (e->dest);
     remove_edge (e);
     e = make_edge (bb1, gsi_bb (*gsi), EDGE_TRUE_VALUE);
     e->probability = profile_probability::very_unlikely ();
     e = make_edge (bb2, gsi_bb (*gsi), EDGE_FALSE_VALUE);
     e->probability = profile_probability::very_unlikely ();
     e = make_edge (bb3, gsi_bb (*gsi), EDGE_TRUE_VALUE);
     e->probability = profile_probability::very_unlikely ();

     basic_block bb4 = create_empty_bb (bb0);
     add_bb_to_loop (bb4, bb0->loop_father);
     e = make_edge (bb0, bb4, EDGE_FALSE_VALUE);
     e->probability = profile_probability::unlikely ();
     make_edge (bb4, gsi_bb (*gsi), EDGE_FALLTHRU);
     set_immediate_dominator (CDI_DOMINATORS, bb4, bb0);
     set_immediate_dominator (CDI_DOMINATORS, gsi_bb (*gsi), bb0);
     gimple_stmt_iterator gsi2 = gsi_after_labels (bb4);
     t2 = fold_build2 (TRUNC_DIV_EXPR, type,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, type, counts
[i], counts[i - 1] )
		counts[i], counts[i - 1])fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, type, counts
[i], counts[i - 1] );
     t2 = force_gimple_operand_gsi (&gsi2, t2, true, NULL_TREE(tree) nullptr, false,
			     GSI_CONTINUE_LINKING);
     t = fold_build2 (TRUNC_MOD_EXPR, type, stopval, t2)fold_build2_loc (((location_t) 0), TRUNC_MOD_EXPR, type, stopval
, t2 );
     t2 = fold_build2 (TRUNC_DIV_EXPR, type, stopval, t2)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, type, stopval
, t2 );
     t = fold_convert (itype, t)fold_convert_loc (((location_t) 0), itype, t);
     t2 = fold_convert (itype, t2)fold_convert_loc (((location_t) 0), itype, t2);
     t = fold_build2 (MULT_EXPR, itype, t,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) )
	       fold_convert (itype, fd->loops[i].step))fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) );
     t = fold_build2 (PLUS_EXPR, itype, fd->loops[i].n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fd->loops
[i].n1, t );
     t2 = fold_build2 (MULT_EXPR, itype, t2,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t2, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i - 1].step) )
		fold_convert (itype, fd->loops[i - 1].step))fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t2, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i - 1].step) );
     t2 = fold_build2 (PLUS_EXPR, itype, fd->loops[i - 1].n1, t2)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fd->loops
[i - 1].n1, t2 );
     t2 = force_gimple_operand_gsi (&gsi2, t2, false, NULL_TREE(tree) nullptr,
			     false, GSI_CONTINUE_LINKING);
     stmt = gimple_build_assign (fd->loops[i - 1].v, t2);
     gsi_insert_after (&gsi2, stmt, GSI_CONTINUE_LINKING);
     if (fd->loops[i].m1)
{
  t2 = fold_build2 (MULT_EXPR, itype, fd->loops[i].m1,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, fd->loops
[i].m1, fd->loops[i - 1].v )
		    fd->loops[i - 1].v)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, fd->loops
[i].m1, fd->loops[i - 1].v );
  t = fold_build2 (PLUS_EXPR, itype, t, t2)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, t2 );
}
     t = force_gimple_operand_gsi (&gsi2, t, false, NULL_TREE(tree) nullptr,
			    false, GSI_CONTINUE_LINKING);
     stmt = gimple_build_assign (fd->loops[i].v, t);
     gsi_insert_after (&gsi2, stmt, GSI_CONTINUE_LINKING);
   }
 /* Fallback implementation.  Evaluate the loops in between
    (inclusive) fd->first_nonrect and fd->last_nonrect at
    runtime unsing temporaries instead of the original iteration
    variables, in the body just bump the counter and compare
    with the desired value.  */
 gimple_stmt_iterator gsi2 = *gsi;
 basic_block entry_bb = gsi_bb (gsi2);
 edge e = split_block (entry_bb, gsi_stmt (gsi2));
 e = split_block (e->dest, (gimple *) NULLnullptr);
 basic_block dom_bb = NULLnullptr;
 basic_block cur_bb = e->src;
 basic_block next_bb = e->dest;
 entry_bb = e->dest;
 *gsi = gsi_after_labels (entry_bb);

 tree *vs = XALLOCAVEC (tree, fd->last_nonrect)((tree *) __builtin_alloca(sizeof (tree) * (fd->last_nonrect
)));
 tree n1 = NULL_TREE(tree) nullptr, n2 = NULL_TREE(tree) nullptr;
 memset (vs, 0, fd->last_nonrect * sizeof (tree));

 for (int j = fd->first_nonrect; j <= fd->last_nonrect; j++)
   {
     tree itype = TREE_TYPE (fd->loops[j].v)((contains_struct_check ((fd->loops[j].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2781, __FUNCTION__))->typed.type);
     bool rect_p = (fd->loops[j].m1 == NULL_TREE(tree) nullptr
	     && fd->loops[j].m2 == NULL_TREE(tree) nullptr
	     && !fd->loops[j].non_rect_referenced);
     gsi2 = gsi_after_labels (cur_bb);
     t = fold_convert (itype, unshare_expr (fd->loops[j].n1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].n1));
     if (fd->loops[j].m1 == NULL_TREE(tree) nullptr)
n1 = rect_p ? build_zero_cst (type) : t;
     else if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
{
  gcc_assert (integer_onep (fd->loops[j].m1))((void)(!(integer_onep (fd->loops[j].m1)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2791, __FUNCTION__), 0 : 0));
  t = unshare_expr (fd->loops[j].n1);
  n1 = fold_build_pointer_plus (vs[j - fd->loops[j].outer], t)fold_build_pointer_plus_loc (((location_t) 0), vs[j - fd->
loops[j].outer], t);
}
     else
{
  n1 = fold_convert (itype, unshare_expr (fd->loops[j].m1))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].m1));
  n1 = fold_build2 (MULT_EXPR, itype,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[j - fd
->loops[j].outer], n1 )
		    vs[j - fd->loops[j].outer], n1)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[j - fd
->loops[j].outer], n1 );
  n1 = fold_build2 (PLUS_EXPR, itype, n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1, t );
}
     n1 = force_gimple_operand_gsi (&gsi2, n1, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     if (j < fd->last_nonrect)
{
  vs[j] = create_tmp_reg (rect_p ? type : itype, ".it");
  expand_omp_build_assign (&gsi2, vs[j], n1);
}
     t = fold_convert (itype, unshare_expr (fd->loops[j].n2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].n2));
     if (fd->loops[j].m2 == NULL_TREE(tree) nullptr)
n2 = rect_p ? counts[j] : t;
     else if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
{
  gcc_assert (integer_onep (fd->loops[j].m2))((void)(!(integer_onep (fd->loops[j].m2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2814, __FUNCTION__), 0 : 0));
  t = unshare_expr (fd->loops[j].n2);
  n2 = fold_build_pointer_plus (vs[j - fd->loops[j].outer], t)fold_build_pointer_plus_loc (((location_t) 0), vs[j - fd->
loops[j].outer], t);
}
     else
{
  n2 = fold_convert (itype, unshare_expr (fd->loops[j].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].m2));
  n2 = fold_build2 (MULT_EXPR, itype,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[j - fd
->loops[j].outer], n2 )
		    vs[j - fd->loops[j].outer], n2)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, vs[j - fd
->loops[j].outer], n2 );
  n2 = fold_build2 (PLUS_EXPR, itype, n2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n2, t );
}
     n2 = force_gimple_operand_gsi (&gsi2, n2, true, NULL_TREE(tree) nullptr,
			     true, GSI_SAME_STMT);
     if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
itype = signed_type_for (itype);
     if (j == fd->last_nonrect)
{
  gcond *cond_stmt
    = expand_omp_build_cond (&gsi2, fd->loops[i].cond_code,
			     n1, n2);
  e = split_block (cur_bb, cond_stmt);
  e->flags = EDGE_TRUE_VALUE;
  edge ne = make_edge (cur_bb, next_bb, EDGE_FALSE_VALUE);
  e->probability = profile_probability::likely ().guessed ();
  ne->probability = e->probability.invert ();
  gsi2 = gsi_after_labels (e->dest);

  t = build_int_cst (itype, (fd->loops[j].cond_code == LT_EXPR
			     ? -1 : 1));
  t = fold_build2 (PLUS_EXPR, itype,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[j].step), t )
		   fold_convert (itype, fd->loops[j].step), t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, fd->loops[j].step), t );
  t = fold_build2 (PLUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n2) )
		   fold_convert (itype, n2))fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n2) );
  t = fold_build2 (MINUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n1) )
		   fold_convert (itype, n1))fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, n1) );
  tree step = fold_convert (itype, fd->loops[j].step)fold_convert_loc (((location_t) 0), itype, fd->loops[j].step
);
  if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2850, __FUNCTION__))->base.u.bits.unsigned_flag)
      && fd->loops[j].cond_code == GT_EXPR)
    t = fold_build2 (TRUNC_DIV_EXPR, itype,fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
		     fold_build1 (NEGATE_EXPR, itype, t),fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) )
		     fold_build1 (NEGATE_EXPR, itype, step))fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, fold_build1_loc
 (((location_t) 0), NEGATE_EXPR, itype, t ), fold_build1_loc (
((location_t) 0), NEGATE_EXPR, itype, step ) );
  else
    t = fold_build2 (TRUNC_DIV_EXPR, itype, t, step)fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, itype, t, step
 );
  t = fold_convert (type, t)fold_convert_loc (((location_t) 0), type, t);
  t = fold_build2 (PLUS_EXPR, type, idx, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, type, idx, t );
  t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
				true, GSI_SAME_STMT);
  e = make_edge (e->dest, next_bb, EDGE_FALLTHRU);
  set_immediate_dominator (CDI_DOMINATORS, next_bb, cur_bb);
  cond_stmt
    = gimple_build_cond (LE_EXPR, t, stopval, NULL_TREE(tree) nullptr,
			 NULL_TREE(tree) nullptr);
  gsi_insert_before (&gsi2, cond_stmt, GSI_SAME_STMT);
  e = split_block (gsi_bb (gsi2), cond_stmt);
  e->flags = EDGE_TRUE_VALUE;
  e->probability = profile_probability::likely ().guessed ();
  ne = make_edge (e->src, entry_bb, EDGE_FALSE_VALUE);
  ne->probability = e->probability.invert ();
  gsi2 = gsi_after_labels (e->dest);
  expand_omp_build_assign (&gsi2, idx, t);
  set_immediate_dominator (CDI_DOMINATORS, entry_bb, dom_bb);
  break;
}
     e = split_block (cur_bb, last_stmt (cur_bb));

     basic_block new_cur_bb = create_empty_bb (cur_bb);
     add_bb_to_loop (new_cur_bb, cur_bb->loop_father);

     gsi2 = gsi_after_labels (e->dest);
     if (rect_p)
t = fold_build2 (PLUS_EXPR, type, vs[j],fold_build2_loc (((location_t) 0), PLUS_EXPR, type, vs[j], build_one_cst
 (type) )
		 build_one_cst (type))fold_build2_loc (((location_t) 0), PLUS_EXPR, type, vs[j], build_one_cst
 (type) );
     else
{
  tree step
    = fold_convert (itype, unshare_expr (fd->loops[j].step))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].step));
  if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
    t = fold_build_pointer_plus (vs[j], step)fold_build_pointer_plus_loc (((location_t) 0), vs[j], step);
  else
    t = fold_build2 (PLUS_EXPR, itype, vs[j], step)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, vs[j], step
 );
}
     t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			    true, GSI_SAME_STMT);
     expand_omp_build_assign (&gsi2, vs[j], t);

     edge ne = split_block (e->dest, last_stmt (e->dest));
     gsi2 = gsi_after_labels (ne->dest);

     gcond *cond_stmt;
     if (next_bb == entry_bb)
/* No need to actually check the outermost condition.  */
cond_stmt
  = gimple_build_cond (EQ_EXPR, boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE],
		       boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE],
		       NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     else
cond_stmt
  = gimple_build_cond (rect_p ? LT_EXPR
			      : fd->loops[j].cond_code,
		       vs[j], n2, NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     gsi_insert_before (&gsi2, cond_stmt, GSI_SAME_STMT);
     edge e3, e4;
     if (next_bb == entry_bb)
{
  e3 = find_edge (ne->dest, next_bb);
  e3->flags = EDGE_FALSE_VALUE;
  dom_bb = ne->dest;
}
     else
e3 = make_edge (ne->dest, next_bb, EDGE_FALSE_VALUE);
     e4 = make_edge (ne->dest, new_cur_bb, EDGE_TRUE_VALUE);
     e4->probability = profile_probability::likely ().guessed ();
     e3->probability = e4->probability.invert ();
     basic_block esrc = e->src;
     make_edge (e->src, ne->dest, EDGE_FALLTHRU);
     cur_bb = new_cur_bb;
     basic_block latch_bb = next_bb;
     next_bb = e->dest;
     remove_edge (e);
     set_immediate_dominator (CDI_DOMINATORS, ne->dest, esrc);
     set_immediate_dominator (CDI_DOMINATORS, latch_bb, ne->dest);
     set_immediate_dominator (CDI_DOMINATORS, cur_bb, ne->dest);
   }
 for (int j = fd->last_nonrect; j >= fd->first_nonrect; j--)
   {
     tree vtype = TREE_TYPE (fd->loops[j].v)((contains_struct_check ((fd->loops[j].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 2939, __FUNCTION__))->typed.type);
     tree itype = vtype;
     if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
itype = signed_type_for (itype);
     bool rect_p = (fd->loops[j].m1 == NULL_TREE(tree) nullptr
	     && fd->loops[j].m2 == NULL_TREE(tree) nullptr
	     && !fd->loops[j].non_rect_referenced);
     if (j == fd->last_nonrect)
{
  t = fold_build2 (MINUS_EXPR, type, stopval, idx)fold_build2_loc (((location_t) 0), MINUS_EXPR, type, stopval,
 idx );
  t = fold_convert (itype, t)fold_convert_loc (((location_t) 0), itype, t);
  tree t2
    = fold_convert (itype, unshare_expr (fd->loops[j].step))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[j].step));
  t = fold_build2 (MULT_EXPR, itype, t, t2)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, t2 );
  if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
    t = fold_build_pointer_plus (n1, t)fold_build_pointer_plus_loc (((location_t) 0), n1, t);
  else
    t = fold_build2 (PLUS_EXPR, itype, n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, n1, t );
}
     else if (rect_p)
{
  t = fold_convert (itype, vs[j])fold_convert_loc (((location_t) 0), itype, vs[j]);
  t = fold_build2 (MULT_EXPR, itype, t,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[j].step) )
		   fold_convert (itype, fd->loops[j].step))fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[j].step) );
  if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
    t = fold_build_pointer_plus (fd->loops[j].n1, t)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[j
].n1, t);
  else
    t = fold_build2 (PLUS_EXPR, itype, fd->loops[j].n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fd->loops
[j].n1, t );
}
     else
t = vs[j];
     t = force_gimple_operand_gsi (gsi, t, false,
			    NULL_TREE(tree) nullptr, true,
			    GSI_SAME_STMT);
     stmt = gimple_build_assign (fd->loops[j].v, t);
     gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
   }
 if (gsi_end_p (*gsi))
   *gsi = gsi_last_bb (gsi_bb (*gsi));
 else
   gsi_prev (gsi);
 if (bb_triang)
   {
     e = split_block (gsi_bb (*gsi), gsi_stmt (*gsi));
     make_edge (bb_triang, e->dest, EDGE_FALLTHRU);
     *gsi = gsi_after_labels (e->dest);
     if (!gsi_end_p (*gsi))
gsi_insert_before (gsi, gimple_build_nop (), GSI_NEW_STMT);
     set_immediate_dominator (CDI_DOMINATORS, e->dest, bb_triang_dom);
   }
}
    else
{
 t = fold_convert (itype, t)fold_convert_loc (((location_t) 0), itype, t);
 t = fold_build2 (MULT_EXPR, itype, t,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) )
	   fold_convert (itype, fd->loops[i].step))fold_build2_loc (((location_t) 0), MULT_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, fd->loops[i].step) );
 if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
   t = fold_build_pointer_plus (fd->loops[i].n1, t)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
].n1, t);
 else
   t = fold_build2 (PLUS_EXPR, itype, fd->loops[i].n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fd->loops
[i].n1, t );
 t = force_gimple_operand_gsi (gsi, t,
			DECL_P (fd->loops[i].v)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (fd->loops[i].v)->base.code))] == tcc_declaration)
			&& TREE_ADDRESSABLE (fd->loops[i].v)((fd->loops[i].v)->base.addressable_flag),
			NULL_TREE(tree) nullptr, false,
			GSI_CONTINUE_LINKING);
 stmt = gimple_build_assign (fd->loops[i].v, t);
 gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
}
    if (i != 0 && (i != fd->last_nonrect || fd->first_nonrect))
{
 t = fold_build2 (TRUNC_DIV_EXPR, type, tem, counts[i])fold_build2_loc (((location_t) 0), TRUNC_DIV_EXPR, type, tem,
 counts[i] );
 t = force_gimple_operand_gsi (gsi, t, false, NULL_TREE(tree) nullptr,
			false, GSI_CONTINUE_LINKING);
 stmt = gimple_build_assign (tem, t);
 gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
}
    if (i == fd->last_nonrect)
i = fd->first_nonrect;
  }
if (fd->non_rect)
  for (i = 0; i <= fd->last_nonrect; i++)
    if (fd->loops[i].m2)
{
 tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3022, __FUNCTION__))->typed.type);

 tree t;
 if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
   {
     gcc_assert (integer_onep (fd->loops[i].m2))((void)(!(integer_onep (fd->loops[i].m2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3027, __FUNCTION__), 0 : 0));
     t = fold_build_pointer_plus (fd->loops[i - fd->loops[i].outer].v,fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
 - fd->loops[i].outer].v, unshare_expr (fd->loops[i].n2
))
			   unshare_expr (fd->loops[i].n2))fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
 - fd->loops[i].outer].v, unshare_expr (fd->loops[i].n2
));
   }
 else
   {
     t = fold_convert (itype, unshare_expr (fd->loops[i].m2))fold_convert_loc (((location_t) 0), itype, unshare_expr (fd->
loops[i].m2));
     t = fold_build2 (MULT_EXPR, itype,fold_build2_loc (((location_t) 0), MULT_EXPR, itype, fd->loops
[i - fd->loops[i].outer].v, t )
	       fd->loops[i - fd->loops[i].outer].v, t)fold_build2_loc (((location_t) 0), MULT_EXPR, itype, fd->loops
[i - fd->loops[i].outer].v, t );
     t = fold_build2 (PLUS_EXPR, itype, t,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, unshare_expr (fd->loops[i].n2))
 )
	       fold_convert (itype,fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, unshare_expr (fd->loops[i].n2))
 )
			     unshare_expr (fd->loops[i].n2)))fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, t, fold_convert_loc
 (((location_t) 0), itype, unshare_expr (fd->loops[i].n2))
 );
   }
 nonrect_bounds[i] = create_tmp_reg (itype, ".bound");
 t = force_gimple_operand_gsi (gsi, t, false,
			NULL_TREE(tree) nullptr, false,
			GSI_CONTINUE_LINKING);
 stmt = gimple_build_assign (nonrect_bounds[i], t);
 gsi_insert_after (gsi, stmt, GSI_CONTINUE_LINKING);
}
3047}

3049/* Helper function for expand_omp_for_*.  Generate code like:
  L10:
V3 += STEP3;
if (V3 cond3 N32) goto BODY_BB; else goto L11;
  L11:
V3 = N31;
V2 += STEP2;
if (V2 cond2 N22) goto BODY_BB; else goto L12;
  L12:
V2 = N21;
V1 += STEP1;
goto BODY_BB;
 For non-rectangular loops, use temporaries stored in nonrect_bounds
 for the upper bounds if M?2 multiplier is present.  Given e.g.
 for (V1 = N11; V1 cond1 N12; V1 += STEP1)
 for (V2 = N21; V2 cond2 N22; V2 += STEP2)
 for (V3 = N31; V3 cond3 N32; V3 += STEP3)
 for (V4 = N41 + M41 * V2; V4 cond4 N42 + M42 * V2; V4 += STEP4)
 do:
  L10:
V4 += STEP4;
if (V4 cond4 NONRECT_BOUND4) goto BODY_BB; else goto L11;
  L11:
V4 = N41 + M41 * V2; // This can be left out if the loop
	     // refers to the immediate parent loop
V3 += STEP3;
if (V3 cond3 N32) goto BODY_BB; else goto L12;
  L12:
V3 = N31;
V2 += STEP2;
if (V2 cond2 N22) goto L120; else goto L13;
  L120:
V4 = N41 + M41 * V2;
NONRECT_BOUND4 = N42 + M42 * V2;
if (V4 cond4 NONRECT_BOUND4) goto BODY_BB; else goto L12;
  L13:
V2 = N21;
V1 += STEP1;
goto L120;  */

3089static basic_block
3090extract_omp_for_update_vars (struct omp_for_data *fd, tree *nonrect_bounds,
	     basic_block cont_bb, basic_block body_bb)
3092{
basic_block last_bb, bb, collapse_bb = NULLnullptr;
int i;
gimple_stmt_iterator gsi;
edge e;
tree t;
gimple *stmt;

last_bb = cont_bb;
for (i = fd->collapse - 1; i >= 0; i--)
  {
    tree vtype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3103, __FUNCTION__))->typed.type);

    bb = create_empty_bb (last_bb);
    add_bb_to_loop (bb, last_bb->loop_father);
    gsi = gsi_start_bb (bb);

    if (i < fd->collapse - 1)
{
 e = make_edge (last_bb, bb, EDGE_FALSE_VALUE);
 e->probability = profile_probability::guessed_always () / 8;

 struct omp_for_data_loop *l = &fd->loops[i + 1];
 if (l->m1 == NULL_TREE(tree) nullptr || l->outer != 1)
   {
     t = l->n1;
     if (l->m1)
{
  if (POINTER_TYPE_P (TREE_TYPE (l->v))(((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3120, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3120, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
    t = fold_build_pointer_plus (fd->loops[i + 1 - l->outer].v,fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
 + 1 - l->outer].v, t)
				 t)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
 + 1 - l->outer].v, t);
  else
    {
      tree t2
	= fold_build2 (MULT_EXPR, TREE_TYPE (t),fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3126, __FUNCTION__))->typed.type), fd->loops[i + 1 - l
->outer].v, l->m1 )
		       fd->loops[i + 1 - l->outer].v, l->m1)fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3126, __FUNCTION__))->typed.type), fd->loops[i + 1 - l
->outer].v, l->m1 );
      t = fold_build2 (PLUS_EXPR, TREE_TYPE (t), t2, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3128, __FUNCTION__))->typed.type), t2, t );
    }
}
     t = force_gimple_operand_gsi (&gsi, t,
			    DECL_P (l->v)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (l->v)->base.code))] == tcc_declaration)
			    && TREE_ADDRESSABLE (l->v)((l->v)->base.addressable_flag),
			    NULL_TREE(tree) nullptr, false,
			    GSI_CONTINUE_LINKING);
     stmt = gimple_build_assign (l->v, t);
     gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
   }
}
    else
collapse_bb = bb;

    set_immediate_dominator (CDI_DOMINATORS, bb, last_bb);

    if (POINTER_TYPE_P (vtype)(((enum tree_code) (vtype)->base.code) == POINTER_TYPE || (
(enum tree_code) (vtype)->base.code) == REFERENCE_TYPE))
t = fold_build_pointer_plus (fd->loops[i].v, fd->loops[i].step)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
].v, fd->loops[i].step);
    else
t = fold_build2 (PLUS_EXPR, vtype, fd->loops[i].v, fd->loops[i].step)fold_build2_loc (((location_t) 0), PLUS_EXPR, vtype, fd->loops
[i].v, fd->loops[i].step );
    t = force_gimple_operand_gsi (&gsi, t,
		    DECL_P (fd->loops[i].v)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (fd->loops[i].v)->base.code))] == tcc_declaration)
		    && TREE_ADDRESSABLE (fd->loops[i].v)((fd->loops[i].v)->base.addressable_flag),
		    NULL_TREE(tree) nullptr, false, GSI_CONTINUE_LINKING);
    stmt = gimple_build_assign (fd->loops[i].v, t);
    gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);

    if (fd->loops[i].non_rect_referenced)
{
 basic_block update_bb = NULLnullptr, prev_bb = NULLnullptr;
 for (int j = i + 1; j <= fd->last_nonrect; j++)
   if (j - fd->loops[j].outer == i)
     {
tree n1, n2;
struct omp_for_data_loop *l = &fd->loops[j];
basic_block this_bb = create_empty_bb (last_bb);
add_bb_to_loop (this_bb, last_bb->loop_father);
gimple_stmt_iterator gsi2 = gsi_start_bb (this_bb);
if (prev_bb)
  {
    e = make_edge (prev_bb, this_bb, EDGE_TRUE_VALUE);
    e->probability
      = profile_probability::guessed_always ().apply_scale (7,
							    8);
    set_immediate_dominator (CDI_DOMINATORS, this_bb, prev_bb);
  }
if (l->m1)
  {
    if (POINTER_TYPE_P (TREE_TYPE (l->v))(((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3177, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3177, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
      t = fold_build_pointer_plus (fd->loops[i].v, l->n1)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
].v, l->n1);
    else
      {
	t = fold_build2 (MULT_EXPR, TREE_TYPE (l->m1), l->m1,fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((l->m1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3181, __FUNCTION__))->typed.type), l->m1, fd->loops
[i].v )
			 fd->loops[i].v)fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((l->m1), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3181, __FUNCTION__))->typed.type), l->m1, fd->loops
[i].v );
	t = fold_build2 (PLUS_EXPR, TREE_TYPE (l->v),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((l->v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3183, __FUNCTION__))->typed.type), t, l->n1 )
			 t, l->n1)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((l->v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3183, __FUNCTION__))->typed.type), t, l->n1 );
      }
    n1 = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
				   false,
				   GSI_CONTINUE_LINKING);
    stmt = gimple_build_assign (l->v, n1);
    gsi_insert_after (&gsi2, stmt, GSI_CONTINUE_LINKING);
    n1 = l->v;
  }
else
  n1 = force_gimple_operand_gsi (&gsi2, l->n1, true,
				 NULL_TREE(tree) nullptr, false,
				 GSI_CONTINUE_LINKING);
if (l->m2)
  {
    if (POINTER_TYPE_P (TREE_TYPE (l->v))(((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3199, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((l->v), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3199, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
      t = fold_build_pointer_plus (fd->loops[i].v, l->n2)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
].v, l->n2);
    else
      {
	t = fold_build2 (MULT_EXPR, TREE_TYPE (l->m2), l->m2,fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((l->m2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3203, __FUNCTION__))->typed.type), l->m2, fd->loops
[i].v )
			 fd->loops[i].v)fold_build2_loc (((location_t) 0), MULT_EXPR, ((contains_struct_check
 ((l->m2), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3203, __FUNCTION__))->typed.type), l->m2, fd->loops
[i].v );
	t = fold_build2 (PLUS_EXPR,fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((nonrect_bounds[j]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3206, __FUNCTION__))->typed.type), t, unshare_expr (l->
n2) )
			 TREE_TYPE (nonrect_bounds[j]),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((nonrect_bounds[j]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3206, __FUNCTION__))->typed.type), t, unshare_expr (l->
n2) )
			 t, unshare_expr (l->n2))fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((nonrect_bounds[j]), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3206, __FUNCTION__))->typed.type), t, unshare_expr (l->
n2) );
      }
    n2 = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
				   false,
				   GSI_CONTINUE_LINKING);
    stmt = gimple_build_assign (nonrect_bounds[j], n2);
    gsi_insert_after (&gsi2, stmt, GSI_CONTINUE_LINKING);
    n2 = nonrect_bounds[j];
  }
else
  n2 = force_gimple_operand_gsi (&gsi2, unshare_expr (l->n2),
				 true, NULL_TREE(tree) nullptr, false,
				 GSI_CONTINUE_LINKING);
gcond *cond_stmt
  = gimple_build_cond (l->cond_code, n1, n2,
		       NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
gsi_insert_after (&gsi2, cond_stmt, GSI_CONTINUE_LINKING);
if (update_bb == NULLnullptr)
  update_bb = this_bb;
e = make_edge (this_bb, bb, EDGE_FALSE_VALUE);
e->probability = profile_probability::guessed_always () / 8;
if (prev_bb == NULLnullptr)
  set_immediate_dominator (CDI_DOMINATORS, this_bb, bb);
prev_bb = this_bb;
     }
 e = make_edge (prev_bb, body_bb, EDGE_TRUE_VALUE);
 e->probability
   = profile_probability::guessed_always ().apply_scale (7, 8);
 body_bb = update_bb;
}

    if (i > 0)
{
 if (fd->loops[i].m2)
   t = nonrect_bounds[i];
 else
   t = unshare_expr (fd->loops[i].n2);
 t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
			false, GSI_CONTINUE_LINKING);
 tree v = fd->loops[i].v;
 if (DECL_P (v)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (v)->base.code))] == tcc_declaration) && TREE_ADDRESSABLE (v)((v)->base.addressable_flag))
   v = force_gimple_operand_gsi (&gsi, v, true, NULL_TREE(tree) nullptr,
			  false, GSI_CONTINUE_LINKING);
 t = fold_build2 (fd->loops[i].cond_code, boolean_type_node, v, t)fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], v, t );
 stmt = gimple_build_cond_empty (t);
 gsi_insert_after (&gsi, stmt, GSI_CONTINUE_LINKING);
 if (walk_tree (gimple_cond_lhs_ptr (as_a <gcond *> (stmt)),walk_tree_1 (gimple_cond_lhs_ptr (as_a <gcond *> (stmt)
), expand_omp_regimplify_p, nullptr, nullptr, nullptr)
	 expand_omp_regimplify_p, NULL, NULL)walk_tree_1 (gimple_cond_lhs_ptr (as_a <gcond *> (stmt)
), expand_omp_regimplify_p, nullptr, nullptr, nullptr)
     || walk_tree (gimple_cond_rhs_ptr (as_a <gcond *> (stmt)),walk_tree_1 (gimple_cond_rhs_ptr (as_a <gcond *> (stmt)
), expand_omp_regimplify_p, nullptr, nullptr, nullptr)
	    expand_omp_regimplify_p, NULL, NULL)walk_tree_1 (gimple_cond_rhs_ptr (as_a <gcond *> (stmt)
), expand_omp_regimplify_p, nullptr, nullptr, nullptr))
   gimple_regimplify_operands (stmt, &gsi);
 e = make_edge (bb, body_bb, EDGE_TRUE_VALUE);
 e->probability = profile_probability::guessed_always ().apply_scale (7, 8);
}
    else
make_edge (bb, body_bb, EDGE_FALLTHRU);
    set_immediate_dominator (CDI_DOMINATORS, bb, last_bb);
    last_bb = bb;
  }

return collapse_bb;
3268}

3270/* Expand #pragma omp ordered depend(source).  */

3272static void
3273expand_omp_ordered_source (gimple_stmt_iterator *gsi, struct omp_for_data *fd,
	   tree *counts, location_t loc)
3275{
enum built_in_function source_ix
  = fd->iter_type == long_integer_type_nodeinteger_types[itk_long]
    ? BUILT_IN_GOMP_DOACROSS_POST : BUILT_IN_GOMP_DOACROSS_ULL_POST;
gimple *g
  = gimple_build_call (builtin_decl_explicit (source_ix), 1,
	 build_fold_addr_expr (counts[fd->ordered])build_fold_addr_expr_loc (((location_t) 0), (counts[fd->ordered
])));
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
3284}

3286/* Expand a single depend from #pragma omp ordered depend(sink:...).  */

3288static void
3289expand_omp_ordered_sink (gimple_stmt_iterator *gsi, struct omp_for_data *fd,
	 tree *counts, tree c, location_t loc,
	 basic_block cont_bb)
3292{
auto_vec<tree, 10> args;
enum built_in_function sink_ix
  = fd->iter_type == long_integer_type_nodeinteger_types[itk_long]
    ? BUILT_IN_GOMP_DOACROSS_WAIT : BUILT_IN_GOMP_DOACROSS_ULL_WAIT;
tree t, off, coff = NULL_TREE(tree) nullptr, deps = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3297, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3297, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3297, __FUNCTION__))), cond = NULL_TREE(tree) nullptr;
int i;
gimple_stmt_iterator gsi2 = *gsi;
bool warned_step = false;

if (deps == NULLnullptr)
  {
    /* Handle doacross(sink: omp_cur_iteration - 1).  */
    gsi_prev (&gsi2);
    edge e1 = split_block (gsi_bb (gsi2), gsi_stmt (gsi2));
    edge e2 = split_block_after_labels (e1->dest);
    gsi2 = gsi_after_labels (e1->dest);
    *gsi = gsi_last_bb (e1->src);
    gimple_stmt_iterator gsi3 = *gsi;

    if (counts[fd->collapse - 1])
{
 gcc_assert (fd->collapse == 1)((void)(!(fd->collapse == 1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3314, __FUNCTION__), 0 : 0));
 t = counts[fd->collapse - 1];
}
    else if (fd->collapse > 1)
t = fd->loop.v;
    else
{
 t = fold_build2 (MINUS_EXPR, TREE_TYPE (fd->loops[0].v),fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3321, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 )
	   fd->loops[0].v, fd->loops[0].n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3321, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 );
 t = fold_convert (fd->iter_type, t)fold_convert_loc (((location_t) 0), fd->iter_type, t);
}

    t = force_gimple_operand_gsi (gsi, t, true, NULL_TREE(tree) nullptr,
		    false, GSI_CONTINUE_LINKING);
    gsi_insert_after (gsi, gimple_build_cond (NE_EXPR, t,
				build_zero_cst (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3329, __FUNCTION__))->typed.type)),
				NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr),
	GSI_NEW_STMT);

    t = fold_build2 (PLUS_EXPR, TREE_TYPE (t), t,fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3333, __FUNCTION__))->typed.type), t, build_minus_one_cst
 (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3334, __FUNCTION__))->typed.type)) )
       build_minus_one_cst (TREE_TYPE (t)))fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3333, __FUNCTION__))->typed.type), t, build_minus_one_cst
 (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3334, __FUNCTION__))->typed.type)) );
    t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
		    true, GSI_SAME_STMT);
    args.safe_push (t);
    for (i = fd->collapse; i < fd->ordered; i++)
{
 t = counts[fd->ordered + 2 + (i - fd->collapse)];
 t = fold_build2 (PLUS_EXPR, TREE_TYPE (t), t,fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3341, __FUNCTION__))->typed.type), t, build_minus_one_cst
 (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3342, __FUNCTION__))->typed.type)) )
	   build_minus_one_cst (TREE_TYPE (t)))fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3341, __FUNCTION__))->typed.type), t, build_minus_one_cst
 (((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3342, __FUNCTION__))->typed.type)) );
 t = fold_convert (fd->iter_type, t)fold_convert_loc (((location_t) 0), fd->iter_type, t);
 t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
			true, GSI_SAME_STMT);
 args.safe_push (t);
}

    gimple *g = gimple_build_call_vec (builtin_decl_explicit (sink_ix),
			 args);
    gimple_set_location (g, loc);
    gsi_insert_before (&gsi2, g, GSI_SAME_STMT);

    edge e3 = make_edge (e1->src, e2->dest, EDGE_FALSE_VALUE);
    e3->probability = profile_probability::guessed_always () / 8;
    e1->probability = e3->probability.invert ();
    e1->flags = EDGE_TRUE_VALUE;
    set_immediate_dominator (CDI_DOMINATORS, e2->dest, e1->src);

    if (fd->ordered > fd->collapse && cont_bb)
{
 if (counts[fd->ordered + 1] == NULL_TREE(tree) nullptr)
   counts[fd->ordered + 1]
     = create_tmp_var (boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], ".first");

 edge e4;
 if (gsi_end_p (gsi3))
   e4 = split_block_after_labels (e1->src);
 else
   {
     gsi_prev (&gsi3);
     e4 = split_block (gsi_bb (gsi3), gsi_stmt (gsi3));
   }
 gsi3 = gsi_last_bb (e4->src);

 gsi_insert_after (&gsi3,
	    gimple_build_cond (NE_EXPR,
			       counts[fd->ordered + 1],
			       boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE],
			       NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr),
	    GSI_NEW_STMT);

 edge e5 = make_edge (e4->src, e2->dest, EDGE_FALSE_VALUE);
 e4->probability = profile_probability::guessed_always () / 8;
 e5->probability = e4->probability.invert ();
 e4->flags = EDGE_TRUE_VALUE;
 set_immediate_dominator (CDI_DOMINATORS, e2->dest, e4->src);
}

    *gsi = gsi_after_labels (e2->dest);
    return;
  }
for (i = 0; i < fd->ordered; i++)
  {
    tree step = NULL_TREE(tree) nullptr;
    off = TREE_PURPOSE (deps)((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3396, __FUNCTION__, (TREE_LIST)))->list.purpose);
    if (TREE_CODE (off)((enum tree_code) (off)->base.code) == TRUNC_DIV_EXPR)
{
 step = TREE_OPERAND (off, 1)(*((const_cast<tree*> (tree_operand_check ((off), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3399, __FUNCTION__)))));
 off = TREE_OPERAND (off, 0)(*((const_cast<tree*> (tree_operand_check ((off), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3400, __FUNCTION__)))));
}
    if (!integer_zerop (off))
{
 gcc_assert (fd->loops[i].cond_code == LT_EXPR((void)(!(fd->loops[i].cond_code == LT_EXPR || fd->loops
[i].cond_code == GT_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3405, __FUNCTION__), 0 : 0))
      || fd->loops[i].cond_code == GT_EXPR)((void)(!(fd->loops[i].cond_code == LT_EXPR || fd->loops
[i].cond_code == GT_EXPR) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3405, __FUNCTION__), 0 : 0));
 bool forward = fd->loops[i].cond_code == LT_EXPR;
 if (step)
   {
     /* Non-simple Fortran DO loops.  If step is variable,
 we don't know at compile even the direction, so can't
 warn.  */
     if (TREE_CODE (step)((enum tree_code) (step)->base.code) != INTEGER_CST)
break;
     forward = tree_int_cst_sgn (step) != -1;
   }
 if (forward ^ OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3416, __FUNCTION__, (TREE_LIST))))->base.public_flag))
   warning_at (loc, 0, "%qs clause with %<sink%> modifier "
		"waiting for lexically later iteration",
	OMP_CLAUSE_DOACROSS_DEPEND (c)(((omp_clause_subcode_check ((c), (OMP_CLAUSE_DOACROSS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3419, __FUNCTION__)))->base.protected_flag)
	? "depend" : "doacross");
 break;
}
    deps = TREE_CHAIN (deps)((contains_struct_check ((deps), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3423, __FUNCTION__))->common.chain);
  }
/* If all offsets corresponding to the collapsed loops are zero,
   this depend clause can be ignored.  FIXME: but there is still a
   flush needed.  We need to emit one __sync_synchronize () for it
   though (perhaps conditionally)?  Solve this together with the
   conservative dependence folding optimization.
if (i >= fd->collapse)
  return;  */

deps = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3433, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3433, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3433, __FUNCTION__)));
gsi_prev (&gsi2);
edge e1 = split_block (gsi_bb (gsi2), gsi_stmt (gsi2));
edge e2 = split_block_after_labels (e1->dest);

gsi2 = gsi_after_labels (e1->dest);
*gsi = gsi_last_bb (e1->src);
for (i = 0; i < fd->ordered; i++)
  {
    tree itype = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3442, __FUNCTION__))->typed.type);
    tree step = NULL_TREE(tree) nullptr;
    tree orig_off = NULL_TREE(tree) nullptr;
    if (POINTER_TYPE_P (itype)(((enum tree_code) (itype)->base.code) == POINTER_TYPE || (
(enum tree_code) (itype)->base.code) == REFERENCE_TYPE))
itype = sizetypesizetype_tab[(int) stk_sizetype];
    if (i)
deps = TREE_CHAIN (deps)((contains_struct_check ((deps), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3448, __FUNCTION__))->common.chain);
    off = TREE_PURPOSE (deps)((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3449, __FUNCTION__, (TREE_LIST)))->list.purpose);
    if (TREE_CODE (off)((enum tree_code) (off)->base.code) == TRUNC_DIV_EXPR)
{
 step = TREE_OPERAND (off, 1)(*((const_cast<tree*> (tree_operand_check ((off), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3452, __FUNCTION__)))));
 off = TREE_OPERAND (off, 0)(*((const_cast<tree*> (tree_operand_check ((off), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3453, __FUNCTION__)))));
 gcc_assert (fd->loops[i].cond_code == LT_EXPR((void)(!(fd->loops[i].cond_code == LT_EXPR && integer_onep
 (fd->loops[i].step) && !(((enum tree_code) (((contains_struct_check
 ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__), 0 : 0))
      && integer_onep (fd->loops[i].step)((void)(!(fd->loops[i].cond_code == LT_EXPR && integer_onep
 (fd->loops[i].step) && !(((enum tree_code) (((contains_struct_check
 ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__), 0 : 0))
      && !POINTER_TYPE_P (TREE_TYPE (fd->loops[i].v)))((void)(!(fd->loops[i].cond_code == LT_EXPR && integer_onep
 (fd->loops[i].step) && !(((enum tree_code) (((contains_struct_check
 ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3456, __FUNCTION__), 0 : 0));
}
    tree s = fold_convert_loc (loc, itype, step ? step : fd->loops[i].step);
    if (step)
{
 off = fold_convert_loc (loc, itype, off);
 orig_off = off;
 off = fold_build2_loc (loc, TRUNC_DIV_EXPR, itype, off, s);
}

    if (integer_zerop (off))
t = boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE];
    else
{
 tree a;
 tree co = fold_convert_loc (loc, itype, off);
 if (POINTER_TYPE_P (TREE_TYPE (fd->loops[i].v))(((enum tree_code) (((contains_struct_check ((fd->loops[i]
.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3472, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3472, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
   {
     if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3474, __FUNCTION__, (TREE_LIST))))->base.public_flag))
co = fold_build1_loc (loc, NEGATE_EXPR, itype, co);
     a = fold_build2_loc (loc, POINTER_PLUS_EXPR,
		   TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3477, __FUNCTION__))->typed.type), fd->loops[i].v,
		   co);
   }
 else if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3480, __FUNCTION__, (TREE_LIST))))->base.public_flag))
   a = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3481, __FUNCTION__))->typed.type),
		 fd->loops[i].v, co);
 else
   a = fold_build2_loc (loc, PLUS_EXPR, TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3484, __FUNCTION__))->typed.type),
		 fd->loops[i].v, co);
 if (step)
   {
     tree t1, t2;
     if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3489, __FUNCTION__, (TREE_LIST))))->base.public_flag))
t1 = fold_build2_loc (loc, GE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		      fd->loops[i].n1);
     else
t1 = fold_build2_loc (loc, LT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		      fd->loops[i].n2);
     if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3495, __FUNCTION__, (TREE_LIST))))->base.public_flag))
t2 = fold_build2_loc (loc, LT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		      fd->loops[i].n2);
     else
t2 = fold_build2_loc (loc, GE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		      fd->loops[i].n1);
     t = fold_build2_loc (loc, LT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE],
		   step, build_int_cst (TREE_TYPE (step)((contains_struct_check ((step), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3502, __FUNCTION__))->typed.type), 0));
     if (TREE_CODE (step)((enum tree_code) (step)->base.code) != INTEGER_CST)
{
  t1 = unshare_expr (t1);
  t1 = force_gimple_operand_gsi (gsi, t1, true, NULL_TREE(tree) nullptr,
				 false, GSI_CONTINUE_LINKING);
  t2 = unshare_expr (t2);
  t2 = force_gimple_operand_gsi (gsi, t2, true, NULL_TREE(tree) nullptr,
				 false, GSI_CONTINUE_LINKING);
}
     t = fold_build3_loc (loc, COND_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE],
		   t, t2, t1);
   }
 else if (fd->loops[i].cond_code == LT_EXPR)
   {
     if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3517, __FUNCTION__, (TREE_LIST))))->base.public_flag))
t = fold_build2_loc (loc, GE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		     fd->loops[i].n1);
     else
t = fold_build2_loc (loc, LT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		     fd->loops[i].n2);
   }
 else if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3524, __FUNCTION__, (TREE_LIST))))->base.public_flag))
   t = fold_build2_loc (loc, GT_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		 fd->loops[i].n2);
 else
   t = fold_build2_loc (loc, LE_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], a,
		 fd->loops[i].n1);
}
    if (cond)
cond = fold_build2_loc (loc, BIT_AND_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], cond, t);
    else
cond = t;

    off = fold_convert_loc (loc, itype, off);

    if (step
 || (fd->loops[i].cond_code == LT_EXPR
     ? !integer_onep (fd->loops[i].step)
     : !integer_minus_onep (fd->loops[i].step)))
{
 if (step == NULL_TREE(tree) nullptr
     && TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3544, __FUNCTION__))->base.u.bits.unsigned_flag)
     && fd->loops[i].cond_code == GT_EXPR)
   t = fold_build2_loc (loc, TRUNC_MOD_EXPR, itype, off,
		 fold_build1_loc (loc, NEGATE_EXPR, itype,
				  s));
 else
   t = fold_build2_loc (loc, TRUNC_MOD_EXPR, itype,
		 orig_off ? orig_off : off, s);
 t = fold_build2_loc (loc, EQ_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], t,
	       build_int_cst (itype, 0));
 if (integer_zerop (t) && !warned_step)
   {
     warning_at (loc, 0, "%qs clause with %<sink%> modifier "
		  "refers to iteration never in the iteration "
		  "space",
	  OMP_CLAUSE_DOACROSS_DEPEND (c)(((omp_clause_subcode_check ((c), (OMP_CLAUSE_DOACROSS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3559, __FUNCTION__)))->base.protected_flag)
	  ? "depend" : "doacross");
     warned_step = true;
   }
 cond = fold_build2_loc (loc, BIT_AND_EXPR, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE],
		  cond, t);
}

    if (i <= fd->collapse - 1 && fd->collapse > 1)
t = fd->loop.v;
    else if (counts[i])
t = counts[i];
    else
{
 t = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3573, __FUNCTION__))->typed.type),
	       fd->loops[i].v, fd->loops[i].n1);
 t = fold_convert_loc (loc, fd->iter_type, t);
}
    if (step)
/* We have divided off by step already earlier.  */;
    else if (TYPE_UNSIGNED (itype)((tree_class_check ((itype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3579, __FUNCTION__))->base.u.bits.unsigned_flag) && fd->loops[i].cond_code == GT_EXPR)
off = fold_build2_loc (loc, TRUNC_DIV_EXPR, itype, off,
	       fold_build1_loc (loc, NEGATE_EXPR, itype,
				s));
    else
off = fold_build2_loc (loc, TRUNC_DIV_EXPR, itype, off, s);
    if (OMP_CLAUSE_DOACROSS_SINK_NEGATIVE (deps)(((tree_check ((deps), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3585, __FUNCTION__, (TREE_LIST))))->base.public_flag))
off = fold_build1_loc (loc, NEGATE_EXPR, itype, off);
    off = fold_convert_loc (loc, fd->iter_type, off);
    if (i <= fd->collapse - 1 && fd->collapse > 1)
{
 if (i)
   off = fold_build2_loc (loc, PLUS_EXPR, fd->iter_type, coff,
		   off);
 if (i < fd->collapse - 1)
   {
     coff = fold_build2_loc (loc, MULT_EXPR, fd->iter_type, off,
		      counts[i]);
     continue;
   }
}
    off = unshare_expr (off);
    t = fold_build2_loc (loc, PLUS_EXPR, fd->iter_type, t, off);
    t = force_gimple_operand_gsi (&gsi2, t, true, NULL_TREE(tree) nullptr,
		    true, GSI_SAME_STMT);
    args.safe_push (t);
  }
gimple *g = gimple_build_call_vec (builtin_decl_explicit (sink_ix), args);
gimple_set_location (g, loc);
gsi_insert_before (&gsi2, g, GSI_SAME_STMT);

cond = unshare_expr (cond);
cond = force_gimple_operand_gsi (gsi, cond, true, NULL_TREE(tree) nullptr, false,
		   GSI_CONTINUE_LINKING);
gsi_insert_after (gsi, gimple_build_cond_empty (cond), GSI_NEW_STMT);
edge e3 = make_edge (e1->src, e2->dest, EDGE_FALSE_VALUE);
e3->probability = profile_probability::guessed_always () / 8;
e1->probability = e3->probability.invert ();
e1->flags = EDGE_TRUE_VALUE;
set_immediate_dominator (CDI_DOMINATORS, e2->dest, e1->src);

*gsi = gsi_after_labels (e2->dest);
3621}

3623/* Expand all #pragma omp ordered depend(source) and
 #pragma omp ordered depend(sink:...) constructs in the current
 #pragma omp for ordered(n) region.  */

3627static void
3628expand_omp_ordered_source_sink (struct omp_region *region,
		struct omp_for_data *fd, tree *counts,
		basic_block cont_bb)
3631{
struct omp_region *inner;
int i;
for (i = fd->collapse - 1; i < fd->ordered; i++)
  if (i == fd->collapse - 1 && fd->collapse > 1)
    counts[i] = NULL_TREE(tree) nullptr;
  else if (i >= fd->collapse && !cont_bb)
    counts[i] = build_zero_cst (fd->iter_type);
  else if (!POINTER_TYPE_P (TREE_TYPE (fd->loops[i].v))(((enum tree_code) (((contains_struct_check ((fd->loops[i]
.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3639, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((fd->loops
[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3639, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
    && integer_onep (fd->loops[i].step))
    counts[i] = NULL_TREE(tree) nullptr;
  else
    counts[i] = create_tmp_var (fd->iter_type, ".orditer");
tree atype
  = build_array_type_nelts (fd->iter_type, fd->ordered - fd->collapse + 1);
counts[fd->ordered] = create_tmp_var (atype, ".orditera");
TREE_ADDRESSABLE (counts[fd->ordered])((counts[fd->ordered])->base.addressable_flag) = 1;
counts[fd->ordered + 1] = NULL_TREE(tree) nullptr;

for (inner = region->inner; inner; inner = inner->next)
  if (inner->type == GIMPLE_OMP_ORDERED)
    {
gomp_ordered *ord_stmt = inner->ord_stmt;
gimple_stmt_iterator gsi = gsi_for_stmt (ord_stmt);
location_t loc = gimple_location (ord_stmt);
tree c;
for (c = gimple_omp_ordered_clauses (ord_stmt);
    c; c = OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3658, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3658, __FUNCTION__))->common.chain))
 if (OMP_CLAUSE_DOACROSS_KIND (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE_DOACROSS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3659, __FUNCTION__))->omp_clause.subcode.doacross_kind) == OMP_CLAUSE_DOACROSS_SOURCE)
   break;
if (c)
 expand_omp_ordered_source (&gsi, fd, counts, loc);
for (c = gimple_omp_ordered_clauses (ord_stmt);
    c; c = OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3664, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3664, __FUNCTION__))->common.chain))
 if (OMP_CLAUSE_DOACROSS_KIND (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE_DOACROSS), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3665, __FUNCTION__))->omp_clause.subcode.doacross_kind) == OMP_CLAUSE_DOACROSS_SINK)
   expand_omp_ordered_sink (&gsi, fd, counts, c, loc, cont_bb);
gsi_remove (&gsi, true);
    }
3669}

3671/* Wrap the body into fd->ordered - fd->collapse loops that aren't
 collapsed.  */

3674static basic_block
3675expand_omp_for_ordered_loops (struct omp_for_data *fd, tree *counts,
	      basic_block cont_bb, basic_block body_bb,
	      basic_block l0_bb, bool ordered_lastprivate)
3678{
if (fd->ordered == fd->collapse)
  return cont_bb;

if (!cont_bb)
  {
    gimple_stmt_iterator gsi = gsi_after_labels (body_bb);
    for (int i = fd->collapse; i < fd->ordered; i++)
{
 tree type = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3687, __FUNCTION__))->typed.type);
 tree n1 = fold_convert (type, fd->loops[i].n1)fold_convert_loc (((location_t) 0), type, fd->loops[i].n1);
 expand_omp_build_assign (&gsi, fd->loops[i].v, n1);
 tree aref = build4 (ARRAY_REF, fd->iter_type, counts[fd->ordered],
	      size_int (i - fd->collapse + 1)size_int_kind (i - fd->collapse + 1, stk_sizetype),
	      NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
 expand_omp_build_assign (&gsi, aref, build_zero_cst (fd->iter_type));
}
    return NULLnullptr;
  }

for (int i = fd->ordered - 1; i >= fd->collapse; i--)
  {
    tree t, type = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3700, __FUNCTION__))->typed.type);
    gimple_stmt_iterator gsi = gsi_after_labels (body_bb);
    if (counts[fd->ordered + 1] && i == fd->collapse)
expand_omp_build_assign (&gsi, counts[fd->ordered + 1],
		 boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE]);
    expand_omp_build_assign (&gsi, fd->loops[i].v,
	       fold_convert (type, fd->loops[i].n1)fold_convert_loc (((location_t) 0), type, fd->loops[i].n1));
    if (counts[i])
expand_omp_build_assign (&gsi, counts[i],
		 build_zero_cst (fd->iter_type));
    tree aref = build4 (ARRAY_REF, fd->iter_type, counts[fd->ordered],
	  size_int (i - fd->collapse + 1)size_int_kind (i - fd->collapse + 1, stk_sizetype),
	  NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
    expand_omp_build_assign (&gsi, aref, build_zero_cst (fd->iter_type));
    if (!gsi_end_p (gsi))
gsi_prev (&gsi);
    else
gsi = gsi_last_bb (body_bb);
    edge e1 = split_block (body_bb, gsi_stmt (gsi));
    basic_block new_body = e1->dest;
    if (body_bb == cont_bb)
cont_bb = new_body;
    edge e2 = NULLnullptr;
    basic_block new_header;
    if (EDGE_COUNT (cont_bb->preds)vec_safe_length (cont_bb->preds) > 0)
{
 gsi = gsi_last_bb (cont_bb);
 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
   t = fold_build_pointer_plus (fd->loops[i].v, fd->loops[i].step)fold_build_pointer_plus_loc (((location_t) 0), fd->loops[i
].v, fd->loops[i].step);
 else
   t = fold_build2 (PLUS_EXPR, type, fd->loops[i].v,fold_build2_loc (((location_t) 0), PLUS_EXPR, type, fd->loops
[i].v, fold_convert_loc (((location_t) 0), type, fd->loops
[i].step) )
	     fold_convert (type, fd->loops[i].step))fold_build2_loc (((location_t) 0), PLUS_EXPR, type, fd->loops
[i].v, fold_convert_loc (((location_t) 0), type, fd->loops
[i].step) );
 expand_omp_build_assign (&gsi, fd->loops[i].v, t);
 if (counts[i])
   {
     t = fold_build2 (PLUS_EXPR, fd->iter_type, counts[i],fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, counts[i], build_int_cst (fd->iter_type, 1) )
	       build_int_cst (fd->iter_type, 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, counts[i], build_int_cst (fd->iter_type, 1) );
     expand_omp_build_assign (&gsi, counts[i], t);
     t = counts[i];
   }
 else
   {
     t = fold_build2 (MINUS_EXPR, TREE_TYPE (fd->loops[i].v),fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3742, __FUNCTION__))->typed.type), fd->loops[i].v, fd
->loops[i].n1 )
	       fd->loops[i].v, fd->loops[i].n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3742, __FUNCTION__))->typed.type), fd->loops[i].v, fd
->loops[i].n1 );
     t = fold_convert (fd->iter_type, t)fold_convert_loc (((location_t) 0), fd->iter_type, t);
     t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
			    true, GSI_SAME_STMT);
   }
 aref = build4 (ARRAY_REF, fd->iter_type, counts[fd->ordered],
	 size_int (i - fd->collapse + 1)size_int_kind (i - fd->collapse + 1, stk_sizetype),
	 NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
 expand_omp_build_assign (&gsi, aref, t);
 if (counts[fd->ordered + 1] && i == fd->ordered - 1)
   expand_omp_build_assign (&gsi, counts[fd->ordered + 1],
		     boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE]);
 gsi_prev (&gsi);
 e2 = split_block (cont_bb, gsi_stmt (gsi));
 new_header = e2->dest;
}
    else
new_header = cont_bb;
    gsi = gsi_after_labels (new_header);
    tree v = force_gimple_operand_gsi (&gsi, fd->loops[i].v, true, NULL_TREE(tree) nullptr,
			 true, GSI_SAME_STMT);
    tree n2
= force_gimple_operand_gsi (&gsi, fold_convert (type, fd->loops[i].n2)fold_convert_loc (((location_t) 0), type, fd->loops[i].n2),
		    true, NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);
    t = build2 (fd->loops[i].cond_code, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE], v, n2);
    gsi_insert_before (&gsi, gimple_build_cond_empty (t), GSI_NEW_STMT);
    edge e3 = split_block (new_header, gsi_stmt (gsi));
    cont_bb = e3->dest;
    remove_edge (e1);
    make_edge (body_bb, new_header, EDGE_FALLTHRU);
    e3->flags = EDGE_FALSE_VALUE;
    e3->probability = profile_probability::guessed_always () / 8;
    e1 = make_edge (new_header, new_body, EDGE_TRUE_VALUE);
    e1->probability = e3->probability.invert ();

    set_immediate_dominator (CDI_DOMINATORS, new_header, body_bb);
    set_immediate_dominator (CDI_DOMINATORS, new_body, new_header);

    if (e2)
{
 class loop *loop = alloc_loop ();
 loop->header = new_header;
 loop->latch = e2->src;
 add_loop (loop, l0_bb->loop_father);
}
  }

/* If there are any lastprivate clauses and it is possible some loops
   might have zero iterations, ensure all the decls are initialized,
   otherwise we could crash evaluating C++ class iterators with lastprivate
   clauses.  */
bool need_inits = false;
for (int i = fd->collapse; ordered_lastprivate && i < fd->ordered; i++)
  if (need_inits)
    {
tree type = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3798, __FUNCTION__))->typed.type);
gimple_stmt_iterator gsi = gsi_after_labels (body_bb);
expand_omp_build_assign (&gsi, fd->loops[i].v,
		 fold_convert (type, fd->loops[i].n1)fold_convert_loc (((location_t) 0), type, fd->loops[i].n1));
    }
  else
    {
tree type = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3805, __FUNCTION__))->typed.type);
tree this_cond = fold_build2 (fd->loops[i].cond_code,fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) )
		      boolean_type_node,fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) )
		      fold_convert (type, fd->loops[i].n1),fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) )
		      fold_convert (type, fd->loops[i].n2))fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) );
if (!integer_onep (this_cond))
 need_inits = true;
    }

return cont_bb;
3815}

3817/* A subroutine of expand_omp_for.  Generate code for a parallel
 loop with any schedule.  Given parameters:

for (V = N1; V cond N2; V += STEP) BODY;

 where COND is "<" or ">", we generate pseudocode

more = GOMP_loop_foo_start (N1, N2, STEP, CHUNK, &istart0, &iend0);
if (more) goto L0; else goto L3;
  L0:
V = istart0;
iend = iend0;
  L1:
BODY;
V += STEP;
if (V cond iend) goto L1; else goto L2;
  L2:
if (GOMP_loop_foo_next (&istart0, &iend0)) goto L0; else goto L3;
  L3:

  If this is a combined omp parallel loop, instead of the call to
  GOMP_loop_foo_start, we call GOMP_loop_foo_next.
  If this is gimple_omp_for_combined_p loop, then instead of assigning
  V and iend in L0 we assign the first two _looptemp_ clause decls of the
  inner GIMPLE_OMP_FOR and V += STEP; and
  if (V cond iend) goto L1; else goto L2; are removed.

  For collapsed loops, given parameters:
    collapse(3)
    for (V1 = N11; V1 cond1 N12; V1 += STEP1)
for (V2 = N21; V2 cond2 N22; V2 += STEP2)
 for (V3 = N31; V3 cond3 N32; V3 += STEP3)
   BODY;

  we generate pseudocode

if (__builtin_expect (N32 cond3 N31, 0)) goto Z0;
if (cond3 is <)
 adj = STEP3 - 1;
else
 adj = STEP3 + 1;
count3 = (adj + N32 - N31) / STEP3;
if (__builtin_expect (N22 cond2 N21, 0)) goto Z0;
if (cond2 is <)
 adj = STEP2 - 1;
else
 adj = STEP2 + 1;
count2 = (adj + N22 - N21) / STEP2;
if (__builtin_expect (N12 cond1 N11, 0)) goto Z0;
if (cond1 is <)
 adj = STEP1 - 1;
else
 adj = STEP1 + 1;
count1 = (adj + N12 - N11) / STEP1;
count = count1 * count2 * count3;
goto Z1;
  Z0:
count = 0;
  Z1:
more = GOMP_loop_foo_start (0, count, 1, CHUNK, &istart0, &iend0);
if (more) goto L0; else goto L3;
  L0:
V = istart0;
T = V;
V3 = N31 + (T % count3) * STEP3;
T = T / count3;
V2 = N21 + (T % count2) * STEP2;
T = T / count2;
V1 = N11 + T * STEP1;
iend = iend0;
  L1:
BODY;
V += 1;
if (V < iend) goto L10; else goto L2;
  L10:
V3 += STEP3;
if (V3 cond3 N32) goto L1; else goto L11;
  L11:
V3 = N31;
V2 += STEP2;
if (V2 cond2 N22) goto L1; else goto L12;
  L12:
V2 = N21;
V1 += STEP1;
goto L1;
  L2:
if (GOMP_loop_foo_next (&istart0, &iend0)) goto L0; else goto L3;
  L3:

    */

3908static void
3909expand_omp_for_generic (struct omp_region *region,
	struct omp_for_data *fd,
	enum built_in_function start_fn,
	enum built_in_function next_fn,
	tree sched_arg,
	gimple *inner_stmt)
3915{
tree type, istart0, iend0, iend;
tree t, vmain, vback, bias = NULL_TREE(tree) nullptr;
basic_block entry_bb, cont_bb, exit_bb, l0_bb, l1_bb, collapse_bb;
basic_block l2_bb = NULLnullptr, l3_bb = NULLnullptr;
gimple_stmt_iterator gsi;
gassign *assign_stmt;
bool in_combined_parallel = is_combined_parallel (region);
bool broken_loop = region->cont == NULLnullptr;
edge e, ne;
tree *counts = NULLnullptr;
int i;
bool ordered_lastprivate = false;

gcc_assert (!broken_loop || !in_combined_parallel)((void)(!(!broken_loop || !in_combined_parallel) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3929, __FUNCTION__), 0 : 0));
gcc_assert (fd->iter_type == long_integer_type_node((void)(!(fd->iter_type == integer_types[itk_long] || !in_combined_parallel
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3931, __FUNCTION__), 0 : 0))
     || !in_combined_parallel)((void)(!(fd->iter_type == integer_types[itk_long] || !in_combined_parallel
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3931, __FUNCTION__), 0 : 0));

entry_bb = region->entry;
cont_bb = region->cont;
collapse_bb = NULLnullptr;
gcc_assert (EDGE_COUNT (entry_bb->succs) == 2)((void)(!(vec_safe_length (entry_bb->succs) == 2) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3936, __FUNCTION__), 0 : 0));
gcc_assert (broken_loop((void)(!(broken_loop || ((*((entry_bb))->succs)[(0)]->
flags & EDGE_FALLTHRU ? (*((entry_bb))->succs)[(1)] : (
*((entry_bb))->succs)[(0)])->dest == ((*((cont_bb))->
succs)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->
succs)[(0)] : (*((cont_bb))->succs)[(1)])->dest) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3938, __FUNCTION__), 0 : 0))
     || BRANCH_EDGE (entry_bb)->dest == FALLTHRU_EDGE (cont_bb)->dest)((void)(!(broken_loop || ((*((entry_bb))->succs)[(0)]->
flags & EDGE_FALLTHRU ? (*((entry_bb))->succs)[(1)] : (
*((entry_bb))->succs)[(0)])->dest == ((*((cont_bb))->
succs)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->
succs)[(0)] : (*((cont_bb))->succs)[(1)])->dest) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3938, __FUNCTION__), 0 : 0));
l0_bb = split_edge (FALLTHRU_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(0)] : (*((entry_bb))->succs)
[(1)]));
l1_bb = single_succ (l0_bb);
if (!broken_loop)
  {
    l2_bb = create_empty_bb (cont_bb);
    gcc_assert (BRANCH_EDGE (cont_bb)->dest == l1_bb((void)(!(((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(
0)])->dest == l1_bb || (single_succ_edge (((*((cont_bb))->
succs)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->
succs)[(1)] : (*((cont_bb))->succs)[(0)])->dest)->dest
 == l1_bb)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3946, __FUNCTION__), 0 : 0))
  || (single_succ_edge (BRANCH_EDGE (cont_bb)->dest)->dest((void)(!(((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(
0)])->dest == l1_bb || (single_succ_edge (((*((cont_bb))->
succs)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->
succs)[(1)] : (*((cont_bb))->succs)[(0)])->dest)->dest
 == l1_bb)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3946, __FUNCTION__), 0 : 0))
      == l1_bb))((void)(!(((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(
0)])->dest == l1_bb || (single_succ_edge (((*((cont_bb))->
succs)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->
succs)[(1)] : (*((cont_bb))->succs)[(0)])->dest)->dest
 == l1_bb)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3946, __FUNCTION__), 0 : 0));
    gcc_assert (EDGE_COUNT (cont_bb->succs) == 2)((void)(!(vec_safe_length (cont_bb->succs) == 2) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3947, __FUNCTION__), 0 : 0));
  }
else
  l2_bb = NULLnullptr;
l3_bb = BRANCH_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(1)] : (*((entry_bb))->succs)
[(0)])->dest;
exit_bb = region->exit;

gsi = gsi_last_nondebug_bb (entry_bb);

gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3956, __FUNCTION__), 0 : 0));
if (fd->ordered
    && omp_find_clause (gimple_omp_for_clauses (fd->for_stmt),
	  OMP_CLAUSE_LASTPRIVATE))
  ordered_lastprivate = false;
tree reductions = NULL_TREE(tree) nullptr;
tree mem = NULL_TREE(tree) nullptr, cond_var = NULL_TREE(tree) nullptr, condtemp = NULL_TREE(tree) nullptr;
tree memv = NULL_TREE(tree) nullptr;
if (fd->lastprivate_conditional)
  {
    tree c = omp_find_clause (gimple_omp_for_clauses (fd->for_stmt),
		OMP_CLAUSE__CONDTEMP_);
    if (fd->have_pointer_condtemp)
condtemp = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3969, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3969, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3969, __FUNCTION__)));
    c = omp_find_clause (OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3970, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3970, __FUNCTION__))->common.chain), OMP_CLAUSE__CONDTEMP_);
    cond_var = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3971, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3971, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3971, __FUNCTION__)));
  }
if (sched_arg)
  {
    if (fd->have_reductemp)
{
 tree c = omp_find_clause (gimple_omp_for_clauses (fd->for_stmt),
		    OMP_CLAUSE__REDUCTEMP_);
 reductions = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3979, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3979, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3979, __FUNCTION__)));
 gcc_assert (TREE_CODE (reductions) == SSA_NAME)((void)(!(((enum tree_code) (reductions)->base.code) == SSA_NAME
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3980, __FUNCTION__), 0 : 0));
 gimple *g = SSA_NAME_DEF_STMT (reductions)(tree_check ((reductions), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3981, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
 reductions = gimple_assign_rhs1 (g);
 OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3983, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3983, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3983, __FUNCTION__))) = reductions;
 entry_bb = gimple_bb (g);
 edge e = split_block (entry_bb, g);
 if (region->entry == entry_bb)
   region->entry = e->dest;
 gsi = gsi_last_bb (entry_bb);
}
    else
reductions = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
    if (fd->have_pointer_condtemp)
{
 tree type = TREE_TYPE (condtemp)((contains_struct_check ((condtemp), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3994, __FUNCTION__))->typed.type);
 memv = create_tmp_var (type);
 TREE_ADDRESSABLE (memv)((memv)->base.addressable_flag) = 1;
 unsigned HOST_WIDE_INTlong sz
   = tree_to_uhwi (TYPE_SIZE_UNIT (TREE_TYPE (type))((tree_class_check ((((contains_struct_check ((type), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3998, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 3998, __FUNCTION__))->type_common.size_unit));
 sz *= fd->lastprivate_conditional;
 expand_omp_build_assign (&gsi, memv, build_int_cst (type, sz),
		   false);
 mem = build_fold_addr_expr (memv)build_fold_addr_expr_loc (((location_t) 0), (memv));
}
    else
mem = null_pointer_nodeglobal_trees[TI_NULL_POINTER];
  }
if (fd->collapse > 1 || fd->ordered)
  {
    int first_zero_iter1 = -1, first_zero_iter2 = -1;
    basic_block zero_iter1_bb = NULLnullptr, zero_iter2_bb = NULLnullptr, l2_dom_bb = NULLnullptr;

    counts = XALLOCAVEC (tree, fd->ordered((tree *) __builtin_alloca(sizeof (tree) * (fd->ordered ? fd
->ordered + 2 + (fd->ordered - fd->collapse) : fd->
collapse)))
		 ? fd->ordered + 2((tree *) __builtin_alloca(sizeof (tree) * (fd->ordered ? fd
->ordered + 2 + (fd->ordered - fd->collapse) : fd->
collapse)))
		   + (fd->ordered - fd->collapse)((tree *) __builtin_alloca(sizeof (tree) * (fd->ordered ? fd
->ordered + 2 + (fd->ordered - fd->collapse) : fd->
collapse)))
		 : fd->collapse)((tree *) __builtin_alloca(sizeof (tree) * (fd->ordered ? fd
->ordered + 2 + (fd->ordered - fd->collapse) : fd->
collapse)));
    expand_omp_for_init_counts (fd, &gsi, entry_bb, counts,
		  zero_iter1_bb, first_zero_iter1,
		  zero_iter2_bb, first_zero_iter2, l2_dom_bb);

    if (zero_iter1_bb)
{
 /* Some counts[i] vars might be uninitialized if
    some loop has zero iterations.  But the body shouldn't
    be executed in that case, so just avoid uninit warnings.  */
 for (i = first_zero_iter1;
      i < (fd->ordered ? fd->ordered : fd->collapse); i++)
   if (SSA_VAR_P (counts[i])(((enum tree_code) (counts[i])->base.code) == VAR_DECL || (
(enum tree_code) (counts[i])->base.code) == PARM_DECL || (
(enum tree_code) (counts[i])->base.code) == RESULT_DECL ||
 ((enum tree_code) (counts[i])->base.code) == SSA_NAME))
     suppress_warning (counts[i], OPT_Wuninitialized);
 gsi_prev (&gsi);
 e = split_block (entry_bb, gsi_stmt (gsi));
 entry_bb = e->dest;
 make_edge (zero_iter1_bb, entry_bb, EDGE_FALLTHRU);
 gsi = gsi_last_nondebug_bb (entry_bb);
 set_immediate_dominator (CDI_DOMINATORS, entry_bb,
		   get_immediate_dominator (CDI_DOMINATORS,
					    zero_iter1_bb));
}
    if (zero_iter2_bb)
{
 /* Some counts[i] vars might be uninitialized if
    some loop has zero iterations.  But the body shouldn't
    be executed in that case, so just avoid uninit warnings.  */
 for (i = first_zero_iter2; i < fd->ordered; i++)
   if (SSA_VAR_P (counts[i])(((enum tree_code) (counts[i])->base.code) == VAR_DECL || (
(enum tree_code) (counts[i])->base.code) == PARM_DECL || (
(enum tree_code) (counts[i])->base.code) == RESULT_DECL ||
 ((enum tree_code) (counts[i])->base.code) == SSA_NAME))
     suppress_warning (counts[i], OPT_Wuninitialized);
 if (zero_iter1_bb)
   make_edge (zero_iter2_bb, entry_bb, EDGE_FALLTHRU);
 else
   {
     gsi_prev (&gsi);
     e = split_block (entry_bb, gsi_stmt (gsi));
     entry_bb = e->dest;
     make_edge (zero_iter2_bb, entry_bb, EDGE_FALLTHRU);
     gsi = gsi_last_nondebug_bb (entry_bb);
     set_immediate_dominator (CDI_DOMINATORS, entry_bb,
		       get_immediate_dominator
			 (CDI_DOMINATORS, zero_iter2_bb));
   }
}
    if (fd->collapse == 1)
{
 counts[0] = fd->loop.n2;
 fd->loop = fd->loops[0];
}
  }

type = TREE_TYPE (fd->loop.v)((contains_struct_check ((fd->loop.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4067, __FUNCTION__))->typed.type);
istart0 = create_tmp_var (fd->iter_type, ".istart0");
iend0 = create_tmp_var (fd->iter_type, ".iend0");
TREE_ADDRESSABLE (istart0)((istart0)->base.addressable_flag) = 1;
TREE_ADDRESSABLE (iend0)((iend0)->base.addressable_flag) = 1;

/* See if we need to bias by LLONG_MIN.  */
if (fd->iter_type == long_long_unsigned_type_nodeinteger_types[itk_unsigned_long_long]
    && TREE_CODE (type)((enum tree_code) (type)->base.code) == INTEGER_TYPE
    && !TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4076, __FUNCTION__))->base.u.bits.unsigned_flag)
    && fd->ordered == 0)
  {
    tree n1, n2;

    if (fd->loop.cond_code == LT_EXPR)
{
 n1 = fd->loop.n1;
 n2 = fold_build2 (PLUS_EXPR, type, fd->loop.n2, fd->loop.step)fold_build2_loc (((location_t) 0), PLUS_EXPR, type, fd->loop
.n2, fd->loop.step );
}
    else
{
 n1 = fold_build2 (MINUS_EXPR, type, fd->loop.n2, fd->loop.step)fold_build2_loc (((location_t) 0), MINUS_EXPR, type, fd->loop
.n2, fd->loop.step );
 n2 = fd->loop.n1;
}
    if (TREE_CODE (n1)((enum tree_code) (n1)->base.code) != INTEGER_CST
 || TREE_CODE (n2)((enum tree_code) (n2)->base.code) != INTEGER_CST
 || ((tree_int_cst_sgn (n1) < 0) ^ (tree_int_cst_sgn (n2) < 0)))
bias = fold_convert (fd->iter_type, TYPE_MIN_VALUE (type))fold_convert_loc (((location_t) 0), fd->iter_type, ((tree_check5
 ((type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4094, __FUNCTION__, (INTEGER_TYPE), (ENUMERAL_TYPE), (BOOLEAN_TYPE
), (REAL_TYPE), (FIXED_POINT_TYPE)))->type_non_common.minval
));
  }

gimple_stmt_iterator gsif = gsi;
gsi_prev (&gsif);

tree arr = NULL_TREE(tree) nullptr;
if (in_combined_parallel)
  {
    gcc_assert (fd->ordered == 0)((void)(!(fd->ordered == 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4103, __FUNCTION__), 0 : 0));
    /* In a combined parallel loop, emit a call to
GOMP_loop_foo_next.  */
    t = build_call_expr (builtin_decl_explicit (next_fn), 2,
	   build_fold_addr_expr (istart0)build_fold_addr_expr_loc (((location_t) 0), (istart0)),
	   build_fold_addr_expr (iend0)build_fold_addr_expr_loc (((location_t) 0), (iend0)));
  }
else
  {
    tree t0, t1, t2, t3, t4;
    /* If this is not a combined parallel loop, emit a call to
GOMP_loop_foo_start in ENTRY_BB.  */
    t4 = build_fold_addr_expr (iend0)build_fold_addr_expr_loc (((location_t) 0), (iend0));
    t3 = build_fold_addr_expr (istart0)build_fold_addr_expr_loc (((location_t) 0), (istart0));
    if (fd->ordered)
{
 t0 = build_int_cst (unsigned_type_nodeinteger_types[itk_unsigned_int],
	      fd->ordered - fd->collapse + 1);
 arr = create_tmp_var (build_array_type_nelts (fd->iter_type,
					fd->ordered
					- fd->collapse + 1),
		".omp_counts");
 DECL_NAMELESS (arr)((contains_struct_check ((arr), (TS_DECL_MINIMAL), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4125, __FUNCTION__))->base.u.bits.nameless_flag) = 1;
 TREE_ADDRESSABLE (arr)((arr)->base.addressable_flag) = 1;
 TREE_STATIC (arr)((arr)->base.static_flag) = 1;
 vec<constructor_elt, va_gc> *v;
 vec_alloc (v, fd->ordered - fd->collapse + 1);
 int idx;

 for (idx = 0; idx < fd->ordered - fd->collapse + 1; idx++)
   {
     tree c;
     if (idx == 0 && fd->collapse > 1)
c = fd->loop.n2;
     else
c = counts[idx + fd->collapse - 1];
     tree purpose = size_int (idx)size_int_kind (idx, stk_sizetype);
     CONSTRUCTOR_APPEND_ELT (v, purpose, c)do { constructor_elt _ce___ = {purpose, c}; vec_safe_push ((v
), _ce___); } while (0);
     if (TREE_CODE (c)((enum tree_code) (c)->base.code) != INTEGER_CST)
TREE_STATIC (arr)((arr)->base.static_flag) = 0;
   }

 DECL_INITIAL (arr)((contains_struct_check ((arr), (TS_DECL_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4145, __FUNCTION__))->decl_common.initial) = build_constructor (TREE_TYPE (arr)((contains_struct_check ((arr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4145, __FUNCTION__))->typed.type), v);
 if (!TREE_STATIC (arr)((arr)->base.static_flag))
   force_gimple_operand_gsi (&gsi, build1 (DECL_EXPR,
				    void_type_nodeglobal_trees[TI_VOID_TYPE], arr),
		      true, NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);
 t1 = build_fold_addr_expr (arr)build_fold_addr_expr_loc (((location_t) 0), (arr));
 t2 = NULL_TREE(tree) nullptr;
}
    else
{
 t2 = fold_convert (fd->iter_type, fd->loop.step)fold_convert_loc (((location_t) 0), fd->iter_type, fd->
loop.step);
 t1 = fd->loop.n2;
 t0 = fd->loop.n1;
 if (gimple_omp_for_combined_into_p (fd->for_stmt))
   {
     tree innerc
= omp_find_clause (gimple_omp_for_clauses (fd->for_stmt),
		   OMP_CLAUSE__LOOPTEMP_);
     gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4163, __FUNCTION__), 0 : 0));
     t0 = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4164, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4164, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4164, __FUNCTION__)));
     innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4165, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4165, __FUNCTION__))->common.chain),
			OMP_CLAUSE__LOOPTEMP_);
     gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4167, __FUNCTION__), 0 : 0));
     t1 = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4168, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4168, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4168, __FUNCTION__)));
   }
 if (POINTER_TYPE_P (TREE_TYPE (t0))(((enum tree_code) (((contains_struct_check ((t0), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4170, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((t0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4170, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
)
     && TYPE_PRECISION (TREE_TYPE (t0))((tree_class_check ((((contains_struct_check ((t0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4171, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4171, __FUNCTION__))->type_common.precision)
 != TYPE_PRECISION (fd->iter_type)((tree_class_check ((fd->iter_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4172, __FUNCTION__))->type_common.precision))
   {
     /* Avoid casting pointers to integer of a different size.  */
     tree itype = signed_type_for (type);
     t1 = fold_convert (fd->iter_type, fold_convert (itype, t1))fold_convert_loc (((location_t) 0), fd->iter_type, fold_convert_loc
 (((location_t) 0), itype, t1));
     t0 = fold_convert (fd->iter_type, fold_convert (itype, t0))fold_convert_loc (((location_t) 0), fd->iter_type, fold_convert_loc
 (((location_t) 0), itype, t0));
   }
 else
   {
     t1 = fold_convert (fd->iter_type, t1)fold_convert_loc (((location_t) 0), fd->iter_type, t1);
     t0 = fold_convert (fd->iter_type, t0)fold_convert_loc (((location_t) 0), fd->iter_type, t0);
   }
 if (bias)
   {
     t1 = fold_build2 (PLUS_EXPR, fd->iter_type, t1, bias)fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, t1, bias );
     t0 = fold_build2 (PLUS_EXPR, fd->iter_type, t0, bias)fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, t0, bias );
   }
}
    if (fd->iter_type == long_integer_type_nodeinteger_types[itk_long] || fd->ordered)
{
 if (fd->chunk_size)
   {
     t = fold_convert (fd->iter_type, fd->chunk_size)fold_convert_loc (((location_t) 0), fd->iter_type, fd->
chunk_size);
     t = omp_adjust_chunk_size (t, fd->simd_schedule);
     if (sched_arg)
{
  if (fd->ordered)
    t = build_call_expr (builtin_decl_explicit (start_fn),
			 8, t0, t1, sched_arg, t, t3, t4,
			 reductions, mem);
  else
    t = build_call_expr (builtin_decl_explicit (start_fn),
			 9, t0, t1, t2, sched_arg, t, t3, t4,
			 reductions, mem);
}
     else if (fd->ordered)
t = build_call_expr (builtin_decl_explicit (start_fn),
		     5, t0, t1, t, t3, t4);
     else
t = build_call_expr (builtin_decl_explicit (start_fn),
		     6, t0, t1, t2, t, t3, t4);
   }
 else if (fd->ordered)
   t = build_call_expr (builtin_decl_explicit (start_fn),
		 4, t0, t1, t3, t4);
 else
   t = build_call_expr (builtin_decl_explicit (start_fn),
		 5, t0, t1, t2, t3, t4);
}
    else
{
 tree t5;
 tree c_bool_type;
 tree bfn_decl;

 /* The GOMP_loop_ull_*start functions have additional boolean
    argument, true for < loops and false for > loops.
    In Fortran, the C bool type can be different from
    boolean_type_node.  */
 bfn_decl = builtin_decl_explicit (start_fn);
 c_bool_type = TREE_TYPE (TREE_TYPE (bfn_decl))((contains_struct_check ((((contains_struct_check ((bfn_decl)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4232, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4232, __FUNCTION__))->typed.type);
 t5 = build_int_cst (c_bool_type,
	      fd->loop.cond_code == LT_EXPR ? 1 : 0);
 if (fd->chunk_size)
   {
     tree bfn_decl = builtin_decl_explicit (start_fn);
     t = fold_convert (fd->iter_type, fd->chunk_size)fold_convert_loc (((location_t) 0), fd->iter_type, fd->
chunk_size);
     t = omp_adjust_chunk_size (t, fd->simd_schedule);
     if (sched_arg)
t = build_call_expr (bfn_decl, 10, t5, t0, t1, t2, sched_arg,
		     t, t3, t4, reductions, mem);
     else
t = build_call_expr (bfn_decl, 7, t5, t0, t1, t2, t, t3, t4);
   }
 else
   t = build_call_expr (builtin_decl_explicit (start_fn),
		 6, t5, t0, t1, t2, t3, t4);
}
  }
if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4251, __FUNCTION__))->typed.type) != boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE])
  t = fold_build2 (NE_EXPR, boolean_type_node,fold_build2_loc (((location_t) 0), NE_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_int_cst (((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4253, __FUNCTION__))->typed.type), 0) )
     t, build_int_cst (TREE_TYPE (t), 0))fold_build2_loc (((location_t) 0), NE_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_int_cst (((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4253, __FUNCTION__))->typed.type), 0) );
t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
		true, GSI_SAME_STMT);
if (arr && !TREE_STATIC (arr)((arr)->base.static_flag))
  {
    tree clobber = build_clobber (TREE_TYPE (arr)((contains_struct_check ((arr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4258, __FUNCTION__))->typed.type));
    gsi_insert_before (&gsi, gimple_build_assign (arr, clobber),
	 GSI_SAME_STMT);
  }
if (fd->have_pointer_condtemp)
  expand_omp_build_assign (&gsi, condtemp, memv, false);
if (fd->have_reductemp)
  {
    gimple *g = gsi_stmt (gsi);
    gsi_remove (&gsi, true);
    release_ssa_name (gimple_assign_lhs (g));

    entry_bb = region->entry;
    gsi = gsi_last_nondebug_bb (entry_bb);

    gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4273, __FUNCTION__), 0 : 0));
  }
gsi_insert_after (&gsi, gimple_build_cond_empty (t), GSI_SAME_STMT);

/* Remove the GIMPLE_OMP_FOR statement.  */
gsi_remove (&gsi, true);

if (gsi_end_p (gsif))
  gsif = gsi_after_labels (gsi_bb (gsif));
gsi_next (&gsif);

/* Iteration setup for sequential loop goes in L0_BB.  */
tree startvar = fd->loop.v;
tree endvar = NULL_TREE(tree) nullptr;

if (gimple_omp_for_combined_p (fd->for_stmt))
  {
    gcc_assert (gimple_code (inner_stmt) == GIMPLE_OMP_FOR((void)(!(gimple_code (inner_stmt) == GIMPLE_OMP_FOR &&
 gimple_omp_for_kind (inner_stmt) == GF_OMP_FOR_KIND_SIMD) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4292, __FUNCTION__), 0 : 0))
  && gimple_omp_for_kind (inner_stmt)((void)(!(gimple_code (inner_stmt) == GIMPLE_OMP_FOR &&
 gimple_omp_for_kind (inner_stmt) == GF_OMP_FOR_KIND_SIMD) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4292, __FUNCTION__), 0 : 0))
     == GF_OMP_FOR_KIND_SIMD)((void)(!(gimple_code (inner_stmt) == GIMPLE_OMP_FOR &&
 gimple_omp_for_kind (inner_stmt) == GF_OMP_FOR_KIND_SIMD) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4292, __FUNCTION__), 0 : 0));
    tree innerc = omp_find_clause (gimple_omp_for_clauses (inner_stmt),
		     OMP_CLAUSE__LOOPTEMP_);
    gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4295, __FUNCTION__), 0 : 0));
    startvar = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4296, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4296, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4296, __FUNCTION__)));
    innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4297, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4297, __FUNCTION__))->common.chain),
		OMP_CLAUSE__LOOPTEMP_);
    gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4299, __FUNCTION__), 0 : 0));
    endvar = OMP_CLAUSE_DECL (innerc)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4300, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4300, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4300, __FUNCTION__)));
  }

gsi = gsi_start_bb (l0_bb);
t = istart0;
if (fd->ordered && fd->collapse == 1)
  t = fold_build2 (MULT_EXPR, fd->iter_type, t,fold_build2_loc (((location_t) 0), MULT_EXPR, fd->iter_type
, t, fold_convert_loc (((location_t) 0), fd->iter_type, fd
->loop.step) )
     fold_convert (fd->iter_type, fd->loop.step))fold_build2_loc (((location_t) 0), MULT_EXPR, fd->iter_type
, t, fold_convert_loc (((location_t) 0), fd->iter_type, fd
->loop.step) );
else if (bias)
  t = fold_build2 (MINUS_EXPR, fd->iter_type, t, bias)fold_build2_loc (((location_t) 0), MINUS_EXPR, fd->iter_type
, t, bias );
if (fd->ordered && fd->collapse == 1)
  {
    if (POINTER_TYPE_P (TREE_TYPE (startvar))(((enum tree_code) (((contains_struct_check ((startvar), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4312, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((startvar), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4312, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
t = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (startvar),fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4313, __FUNCTION__))->typed.type), fd->loop.n1, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], t) )
	 fd->loop.n1, fold_convert (sizetype, t))fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4313, __FUNCTION__))->typed.type), fd->loop.n1, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], t) );
    else
{
 t = fold_convert (TREE_TYPE (startvar), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4317, __FUNCTION__))->typed.type), t);
 t = fold_build2 (PLUS_EXPR, TREE_TYPE (startvar),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4318, __FUNCTION__))->typed.type), fd->loop.n1, t )
	   fd->loop.n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4318, __FUNCTION__))->typed.type), fd->loop.n1, t );
}
  }
else
  {
    if (POINTER_TYPE_P (TREE_TYPE (startvar))(((enum tree_code) (((contains_struct_check ((startvar), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4324, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((startvar), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4324, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
t = fold_convert (signed_type_for (TREE_TYPE (startvar)), t)fold_convert_loc (((location_t) 0), signed_type_for (((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4325, __FUNCTION__))->typed.type)), t);
    t = fold_convert (TREE_TYPE (startvar), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4326, __FUNCTION__))->typed.type), t);
  }
t = force_gimple_operand_gsi (&gsi, t,
		DECL_P (startvar)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (startvar)->base.code))] == tcc_declaration)
		&& TREE_ADDRESSABLE (startvar)((startvar)->base.addressable_flag),
		NULL_TREE(tree) nullptr, false, GSI_CONTINUE_LINKING);
assign_stmt = gimple_build_assign (startvar, t);
gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
if (cond_var)
  {
    tree itype = TREE_TYPE (cond_var)((contains_struct_check ((cond_var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4336, __FUNCTION__))->typed.type);
    /* For lastprivate(conditional:) itervar, we need some iteration
counter that starts at unsigned non-zero and increases.
Prefer as few IVs as possible, so if we can use startvar
itself, use that, or startvar + constant (those would be
incremented with step), and as last resort use the s0 + 1
incremented by 1.  */
    if ((fd->ordered && fd->collapse == 1)
 || bias
 || POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
 || TREE_CODE (fd->loop.n1)((enum tree_code) (fd->loop.n1)->base.code) != INTEGER_CST
 || fd->loop.cond_code != LT_EXPR)
t = fold_build2 (PLUS_EXPR, itype, fold_convert (itype, istart0),fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, istart0), build_int_cst (itype, 1)
 )
	 build_int_cst (itype, 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, istart0), build_int_cst (itype, 1)
 );
    else if (tree_int_cst_sgn (fd->loop.n1) == 1)
t = fold_convert (itype, t)fold_convert_loc (((location_t) 0), itype, t);
    else
{
 tree c = fold_convert (itype, fd->loop.n1)fold_convert_loc (((location_t) 0), itype, fd->loop.n1);
 c = fold_build2 (MINUS_EXPR, itype, build_int_cst (itype, 1), c)fold_build2_loc (((location_t) 0), MINUS_EXPR, itype, build_int_cst
 (itype, 1), c );
 t = fold_build2 (PLUS_EXPR, itype, fold_convert (itype, t), c)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, fold_convert_loc
 (((location_t) 0), itype, t), c );
}
    t = force_gimple_operand_gsi (&gsi, t, false,
		    NULL_TREE(tree) nullptr, false, GSI_CONTINUE_LINKING);
    assign_stmt = gimple_build_assign (cond_var, t);
    gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
  }

t = iend0;
if (fd->ordered && fd->collapse == 1)
  t = fold_build2 (MULT_EXPR, fd->iter_type, t,fold_build2_loc (((location_t) 0), MULT_EXPR, fd->iter_type
, t, fold_convert_loc (((location_t) 0), fd->iter_type, fd
->loop.step) )
     fold_convert (fd->iter_type, fd->loop.step))fold_build2_loc (((location_t) 0), MULT_EXPR, fd->iter_type
, t, fold_convert_loc (((location_t) 0), fd->iter_type, fd
->loop.step) );
else if (bias)
  t = fold_build2 (MINUS_EXPR, fd->iter_type, t, bias)fold_build2_loc (((location_t) 0), MINUS_EXPR, fd->iter_type
, t, bias );
if (fd->ordered && fd->collapse == 1)
  {
    if (POINTER_TYPE_P (TREE_TYPE (startvar))(((enum tree_code) (((contains_struct_check ((startvar), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4372, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((startvar), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4372, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
t = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (startvar),fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4373, __FUNCTION__))->typed.type), fd->loop.n1, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], t) )
	 fd->loop.n1, fold_convert (sizetype, t))fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4373, __FUNCTION__))->typed.type), fd->loop.n1, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], t) );
    else
{
 t = fold_convert (TREE_TYPE (startvar), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4377, __FUNCTION__))->typed.type), t);
 t = fold_build2 (PLUS_EXPR, TREE_TYPE (startvar),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4378, __FUNCTION__))->typed.type), fd->loop.n1, t )
	   fd->loop.n1, t)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4378, __FUNCTION__))->typed.type), fd->loop.n1, t );
}
  }
else
  {
    if (POINTER_TYPE_P (TREE_TYPE (startvar))(((enum tree_code) (((contains_struct_check ((startvar), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4384, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((startvar), (
TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4384, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
t = fold_convert (signed_type_for (TREE_TYPE (startvar)), t)fold_convert_loc (((location_t) 0), signed_type_for (((contains_struct_check
 ((startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4385, __FUNCTION__))->typed.type)), t);
    t = fold_convert (TREE_TYPE (startvar), t)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(startvar), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4386, __FUNCTION__))->typed.type), t);
  }
iend = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
		   false, GSI_CONTINUE_LINKING);
if (endvar)
  {
    assign_stmt = gimple_build_assign (endvar, iend);
    gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
    if (useless_type_conversion_p (TREE_TYPE (fd->loop.v)((contains_struct_check ((fd->loop.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4394, __FUNCTION__))->typed.type), TREE_TYPE (iend)((contains_struct_check ((iend), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4394, __FUNCTION__))->typed.type)))
assign_stmt = gimple_build_assign (fd->loop.v, iend);
    else
assign_stmt = gimple_build_assign (fd->loop.v, NOP_EXPR, iend);
    gsi_insert_after (&gsi, assign_stmt, GSI_CONTINUE_LINKING);
  }
/* Handle linear clause adjustments.  */
tree itercnt = NULL_TREE(tree) nullptr;
if (gimple_omp_for_kind (fd->for_stmt) == GF_OMP_FOR_KIND_FOR)
  for (tree c = gimple_omp_for_clauses (fd->for_stmt);
c; c = OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4404, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4404, __FUNCTION__))->common.chain))
    if (OMP_CLAUSE_CODE (c)((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4405, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.code == OMP_CLAUSE_LINEAR
 && !OMP_CLAUSE_LINEAR_NO_COPYIN (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE_LINEAR), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4406, __FUNCTION__))->base.public_flag))
{
 tree d = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4408, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4408, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4408, __FUNCTION__)));
 tree t = d, a, dest;
 if (omp_privatize_by_reference (t))
   t = build_simple_mem_ref_loc (OMP_CLAUSE_LOCATION (c)((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4411, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.locus, t);
 tree type = TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4412, __FUNCTION__))->typed.type);
 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
   type = sizetypesizetype_tab[(int) stk_sizetype];
 dest = unshare_expr (t);
 tree v = create_tmp_var (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4416, __FUNCTION__))->typed.type), NULLnullptr);
 expand_omp_build_assign (&gsif, v, t);
 if (itercnt == NULL_TREE(tree) nullptr)
   {
     itercnt = startvar;
     tree n1 = fd->loop.n1;
     if (POINTER_TYPE_P (TREE_TYPE (itercnt))(((enum tree_code) (((contains_struct_check ((itercnt), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4422, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
 || ((enum tree_code) (((contains_struct_check ((itercnt), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4422, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
{
  itercnt
    = fold_convert (signed_type_for (TREE_TYPE (itercnt)),fold_convert_loc (((location_t) 0), signed_type_for (((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4425, __FUNCTION__))->typed.type)), itercnt)
		    itercnt)fold_convert_loc (((location_t) 0), signed_type_for (((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4425, __FUNCTION__))->typed.type)), itercnt);
  n1 = fold_convert (TREE_TYPE (itercnt), n1)fold_convert_loc (((location_t) 0), ((contains_struct_check (
(itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4427, __FUNCTION__))->typed.type), n1);
}
     itercnt = fold_build2 (MINUS_EXPR, TREE_TYPE (itercnt),fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4429, __FUNCTION__))->typed.type), itercnt, n1 )
		     itercnt, n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4429, __FUNCTION__))->typed.type), itercnt, n1 );
     itercnt = fold_build2 (EXACT_DIV_EXPR, TREE_TYPE (itercnt),fold_build2_loc (((location_t) 0), EXACT_DIV_EXPR, ((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4431, __FUNCTION__))->typed.type), itercnt, fd->loop.
step )
		     itercnt, fd->loop.step)fold_build2_loc (((location_t) 0), EXACT_DIV_EXPR, ((contains_struct_check
 ((itercnt), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4431, __FUNCTION__))->typed.type), itercnt, fd->loop.
step );
     itercnt = force_gimple_operand_gsi (&gsi, itercnt, true,
				  NULL_TREE(tree) nullptr, false,
				  GSI_CONTINUE_LINKING);
   }
 a = fold_build2 (MULT_EXPR, type,fold_build2_loc (((location_t) 0), MULT_EXPR, type, fold_convert_loc
 (((location_t) 0), type, itercnt), fold_convert_loc (((location_t
) 0), type, (*(omp_clause_elt_check (((omp_clause_subcode_check
 ((c), (OMP_CLAUSE_LINEAR), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__)))) )
	   fold_convert (type, itercnt),fold_build2_loc (((location_t) 0), MULT_EXPR, type, fold_convert_loc
 (((location_t) 0), type, itercnt), fold_convert_loc (((location_t
) 0), type, (*(omp_clause_elt_check (((omp_clause_subcode_check
 ((c), (OMP_CLAUSE_LINEAR), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__)))) )
	   fold_convert (type, OMP_CLAUSE_LINEAR_STEP (c)))fold_build2_loc (((location_t) 0), MULT_EXPR, type, fold_convert_loc
 (((location_t) 0), type, itercnt), fold_convert_loc (((location_t
) 0), type, (*(omp_clause_elt_check (((omp_clause_subcode_check
 ((c), (OMP_CLAUSE_LINEAR), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__))), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4439, __FUNCTION__)))) );
 t = fold_build2 (type == TREE_TYPE (t) ? PLUS_EXPRfold_build2_loc (((location_t) 0), type == ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4440, __FUNCTION__))->typed.type) ? PLUS_EXPR : POINTER_PLUS_EXPR
, ((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4441, __FUNCTION__))->typed.type), v, a )
	   : POINTER_PLUS_EXPR, TREE_TYPE (t), v, a)fold_build2_loc (((location_t) 0), type == ((contains_struct_check
 ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4440, __FUNCTION__))->typed.type) ? PLUS_EXPR : POINTER_PLUS_EXPR
, ((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4441, __FUNCTION__))->typed.type), v, a );
 t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
			false, GSI_CONTINUE_LINKING);
 expand_omp_build_assign (&gsi, dest, t, true);
}
if (fd->collapse > 1)
  expand_omp_for_init_vars (fd, &gsi, counts, NULLnullptr, inner_stmt, startvar);

if (fd->ordered)
  {
    /* Until now, counts array contained number of iterations or
variable containing it for ith loop.  From now on, we usually need
those counts only for collapsed loops, and only for the 2nd
till the last collapsed one.  Move those one element earlier,
we'll use counts[fd->collapse - 1] for the first source/sink
iteration counter and so on and counts[fd->ordered]
as the array holding the current counter values for
depend(source).  For doacross(sink:omp_cur_iteration - 1) we need
the counts from fd->collapse to fd->ordered - 1; make a copy of
those to counts[fd->ordered + 2] and onwards.
counts[fd->ordered + 1] can be a flag whether it is the first
iteration with a new collapsed counter (used only if
fd->ordered > fd->collapse).  */
    if (fd->ordered > fd->collapse)
memcpy (counts + fd->ordered + 2, counts + fd->collapse,
(fd->ordered - fd->collapse) * sizeof (counts[0]));
    if (fd->collapse > 1)
memmove (counts, counts + 1, (fd->collapse - 1) * sizeof (counts[0]));
    if (broken_loop)
{
 int i;
 for (i = fd->collapse; i < fd->ordered; i++)
   {
     tree type = TREE_TYPE (fd->loops[i].v)((contains_struct_check ((fd->loops[i].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4474, __FUNCTION__))->typed.type);
     tree this_cond
= fold_build2 (fd->loops[i].cond_code, boolean_type_node,fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) )
	       fold_convert (type, fd->loops[i].n1),fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) )
	       fold_convert (type, fd->loops[i].n2))fold_build2_loc (((location_t) 0), fd->loops[i].cond_code,
 global_trees[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t
) 0), type, fd->loops[i].n1), fold_convert_loc (((location_t
) 0), type, fd->loops[i].n2) );
     if (!integer_onep (this_cond))
break;
   }
 if (i < fd->ordered)
   {
     if (entry_bb->loop_father != l0_bb->loop_father)
{
  remove_bb_from_loops (l0_bb);
  add_bb_to_loop (l0_bb, entry_bb->loop_father);
  gcc_assert (single_succ (l0_bb) == l1_bb)((void)(!(single_succ (l0_bb) == l1_bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4488, __FUNCTION__), 0 : 0));
}
     cont_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)(((cfun + 0))->cfg->x_exit_block_ptr)->prev_bb);
     add_bb_to_loop (cont_bb, l0_bb->loop_father);
     gimple_stmt_iterator gsi = gsi_after_labels (cont_bb);
     gimple *g = gimple_build_omp_continue (fd->loop.v, fd->loop.v);
     gsi_insert_before (&gsi, g, GSI_SAME_STMT);
     make_edge (cont_bb, l3_bb, EDGE_FALLTHRU);
     make_edge (cont_bb, l1_bb, 0);
     l2_bb = create_empty_bb (cont_bb);
     broken_loop = false;
   }
}
    expand_omp_ordered_source_sink (region, fd, counts, cont_bb);
    cont_bb = expand_omp_for_ordered_loops (fd, counts, cont_bb, l1_bb,
			      l0_bb, ordered_lastprivate);
    if (counts[fd->collapse - 1])
{
 gcc_assert (fd->collapse == 1)((void)(!(fd->collapse == 1) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4507, __FUNCTION__), 0 : 0));
 gsi = gsi_last_bb (l0_bb);
 expand_omp_build_assign (&gsi, counts[fd->collapse - 1],
		   istart0, true);
 if (cont_bb)
   {
     gsi = gsi_last_bb (cont_bb);
     t = fold_build2 (PLUS_EXPR, fd->iter_type,fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, counts[fd->collapse - 1], build_int_cst (fd->iter_type
, 1) )
	       counts[fd->collapse - 1],fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, counts[fd->collapse - 1], build_int_cst (fd->iter_type
, 1) )
	       build_int_cst (fd->iter_type, 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, fd->iter_type
, counts[fd->collapse - 1], build_int_cst (fd->iter_type
, 1) );
     expand_omp_build_assign (&gsi, counts[fd->collapse - 1], t);
     tree aref = build4 (ARRAY_REF, fd->iter_type,
		  counts[fd->ordered], size_zero_nodeglobal_trees[TI_SIZE_ZERO],
		  NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     expand_omp_build_assign (&gsi, aref, counts[fd->collapse - 1]);
   }
 t = counts[fd->collapse - 1];
}
    else if (fd->collapse > 1)
t = fd->loop.v;
    else
{
 t = fold_build2 (MINUS_EXPR, TREE_TYPE (fd->loops[0].v),fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4529, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 )
	   fd->loops[0].v, fd->loops[0].n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4529, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 );
 t = fold_convert (fd->iter_type, t)fold_convert_loc (((location_t) 0), fd->iter_type, t);
}
    gsi = gsi_last_bb (l0_bb);
    tree aref = build4 (ARRAY_REF, fd->iter_type, counts[fd->ordered],
	  size_zero_nodeglobal_trees[TI_SIZE_ZERO], NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
    t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
		    false, GSI_CONTINUE_LINKING);
    expand_omp_build_assign (&gsi, aref, t, true);
  }

if (!broken_loop)
  {
    /* Code to control the increment and predicate for the sequential
loop goes in the CONT_BB.  */
    gsi = gsi_last_nondebug_bb (cont_bb);
    gomp_continue *cont_stmt = as_a <gomp_continue *> (gsi_stmt (gsi));
    gcc_assert (gimple_code (cont_stmt) == GIMPLE_OMP_CONTINUE)((void)(!(gimple_code (cont_stmt) == GIMPLE_OMP_CONTINUE) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4547, __FUNCTION__), 0 : 0));
    vmain = gimple_omp_continue_control_use (cont_stmt);
    vback = gimple_omp_continue_control_def (cont_stmt);

    if (cond_var)
{
 tree itype = TREE_TYPE (cond_var)((contains_struct_check ((cond_var), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4553, __FUNCTION__))->typed.type);
 tree t2;
 if ((fd->ordered && fd->collapse == 1)
      || bias
      || POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE)
      || TREE_CODE (fd->loop.n1)((enum tree_code) (fd->loop.n1)->base.code) != INTEGER_CST
      || fd->loop.cond_code != LT_EXPR)
   t2 = build_int_cst (itype, 1);
 else
   t2 = fold_convert (itype, fd->loop.step)fold_convert_loc (((location_t) 0), itype, fd->loop.step);
 t2 = fold_build2 (PLUS_EXPR, itype, cond_var, t2)fold_build2_loc (((location_t) 0), PLUS_EXPR, itype, cond_var
, t2 );
 t2 = force_gimple_operand_gsi (&gsi, t2, false,
			 NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);
 assign_stmt = gimple_build_assign (cond_var, t2);
 gsi_insert_before (&gsi, assign_stmt, GSI_SAME_STMT);
}

    if (!gimple_omp_for_combined_p (fd->for_stmt))
{
 if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
   t = fold_build_pointer_plus (vmain, fd->loop.step)fold_build_pointer_plus_loc (((location_t) 0), vmain, fd->
loop.step);
 else
   t = fold_build2 (PLUS_EXPR, type, vmain, fd->loop.step)fold_build2_loc (((location_t) 0), PLUS_EXPR, type, vmain, fd
->loop.step );
 t = force_gimple_operand_gsi (&gsi, t,
			DECL_P (vback)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (vback)->base.code))] == tcc_declaration)
			&& TREE_ADDRESSABLE (vback)((vback)->base.addressable_flag),
			NULL_TREE(tree) nullptr, true, GSI_SAME_STMT);
 assign_stmt = gimple_build_assign (vback, t);
 gsi_insert_before (&gsi, assign_stmt, GSI_SAME_STMT);

 if (fd->ordered && counts[fd->collapse - 1] == NULL_TREE(tree) nullptr)
   {
     tree tem;
     if (fd->collapse > 1)
tem = fd->loop.v;
     else
{
  tem = fold_build2 (MINUS_EXPR, TREE_TYPE (fd->loops[0].v),fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4590, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 )
		     fd->loops[0].v, fd->loops[0].n1)fold_build2_loc (((location_t) 0), MINUS_EXPR, ((contains_struct_check
 ((fd->loops[0].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4590, __FUNCTION__))->typed.type), fd->loops[0].v, fd
->loops[0].n1 );
  tem = fold_convert (fd->iter_type, tem)fold_convert_loc (((location_t) 0), fd->iter_type, tem);
}
     tree aref = build4 (ARRAY_REF, fd->iter_type,
		  counts[fd->ordered], size_zero_nodeglobal_trees[TI_SIZE_ZERO],
		  NULL_TREE(tree) nullptr, NULL_TREE(tree) nullptr);
     tem = force_gimple_operand_gsi (&gsi, tem, true, NULL_TREE(tree) nullptr,
			      true, GSI_SAME_STMT);
     expand_omp_build_assign (&gsi, aref, tem);
   }

 t = build2 (fd->loop.cond_code, boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE],
      DECL_P (vback)(tree_code_type_tmpl <0>::tree_code_type[(int) (((enum tree_code
) (vback)->base.code))] == tcc_declaration) && TREE_ADDRESSABLE (vback)((vback)->base.addressable_flag) ? t : vback,
      iend);
 gcond *cond_stmt = gimple_build_cond_empty (t);
 gsi_insert_before (&gsi, cond_stmt, GSI_SAME_STMT);
}

    /* Remove GIMPLE_OMP_CONTINUE.  */
    gsi_remove (&gsi, true);

    if (fd->collapse > 1 && !gimple_omp_for_combined_p (fd->for_stmt))
collapse_bb = extract_omp_for_update_vars (fd, NULLnullptr, cont_bb, l1_bb);

    /* Emit code to get the next parallel iteration in L2_BB.  */
    gsi = gsi_start_bb (l2_bb);

    t = build_call_expr (builtin_decl_explicit (next_fn), 2,
	   build_fold_addr_expr (istart0)build_fold_addr_expr_loc (((location_t) 0), (istart0)),
	   build_fold_addr_expr (iend0)build_fold_addr_expr_loc (((location_t) 0), (iend0)));
    t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE(tree) nullptr,
		    false, GSI_CONTINUE_LINKING);
    if (TREE_TYPE (t)((contains_struct_check ((t), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4623, __FUNCTION__))->typed.type) != boolean_type_nodeglobal_trees[TI_BOOLEAN_TYPE])
t = fold_build2 (NE_EXPR, boolean_type_node,fold_build2_loc (((location_t) 0), NE_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_int_cst (((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4625, __FUNCTION__))->typed.type), 0) )
	 t, build_int_cst (TREE_TYPE (t), 0))fold_build2_loc (((location_t) 0), NE_EXPR, global_trees[TI_BOOLEAN_TYPE
], t, build_int_cst (((contains_struct_check ((t), (TS_TYPED)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4625, __FUNCTION__))->typed.type), 0) );
    gcond *cond_stmt = gimple_build_cond_empty (t);
    gsi_insert_after (&gsi, cond_stmt, GSI_CONTINUE_LINKING);
  }

/* Add the loop cleanup function.  */
gsi = gsi_last_nondebug_bb (exit_bb);
if (gimple_omp_return_nowait_p (gsi_stmt (gsi)))
  t = builtin_decl_explicit (BUILT_IN_GOMP_LOOP_END_NOWAIT);
else if (gimple_omp_return_lhs (gsi_stmt (gsi)))
  t = builtin_decl_explicit (BUILT_IN_GOMP_LOOP_END_CANCEL);
else
  t = builtin_decl_explicit (BUILT_IN_GOMP_LOOP_END);
gcall *call_stmt = gimple_build_call (t, 0);
if (fd->ordered)
  {
    tree arr = counts[fd->ordered];
    tree clobber = build_clobber (TREE_TYPE (arr)((contains_struct_check ((arr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4642, __FUNCTION__))->typed.type));
    gsi_insert_after (&gsi, gimple_build_assign (arr, clobber),
	GSI_SAME_STMT);
  }
if (gimple_omp_return_lhs (gsi_stmt (gsi)))
  {
    gimple_call_set_lhs (call_stmt, gimple_omp_return_lhs (gsi_stmt (gsi)));
    if (fd->have_reductemp)
{
 gimple *g = gimple_build_assign (reductions, NOP_EXPR,
			   gimple_call_lhs (call_stmt));
 gsi_insert_after (&gsi, g, GSI_SAME_STMT);
}
  }
gsi_insert_after (&gsi, call_stmt, GSI_SAME_STMT);
gsi_remove (&gsi, true);

/* Connect the new blocks.  */
find_edge (entry_bb, l0_bb)->flags = EDGE_TRUE_VALUE;
find_edge (entry_bb, l3_bb)->flags = EDGE_FALSE_VALUE;

if (!broken_loop)
  {
    gimple_seq phis;

    e = find_edge (cont_bb, l3_bb);
    ne = make_edge (l2_bb, l3_bb, EDGE_FALSE_VALUE);

    phis = phi_nodes (l3_bb);
    for (gsi = gsi_start (phis); !gsi_end_p (gsi); gsi_next (&gsi))
{
 gimple *phi = gsi_stmt (gsi);
 SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, ne),set_ssa_use_from_ptr (gimple_phi_arg_imm_use_ptr (((phi)), ((
ne)->dest_idx)), gimple_phi_arg_def (((phi)), ((e)->dest_idx
)))
   PHI_ARG_DEF_FROM_EDGE (phi, e))set_ssa_use_from_ptr (gimple_phi_arg_imm_use_ptr (((phi)), ((
ne)->dest_idx)), gimple_phi_arg_def (((phi)), ((e)->dest_idx
)));
}
    remove_edge (e);

    make_edge (cont_bb, l2_bb, EDGE_FALSE_VALUE);
    e = find_edge (cont_bb, l1_bb);
    if (e == NULLnullptr)
{
 e = BRANCH_EDGE (cont_bb)((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU ?
 (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(0)
]);
 gcc_assert (single_succ (e->dest) == l1_bb)((void)(!(single_succ (e->dest) == l1_bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4684, __FUNCTION__), 0 : 0));
}
    if (gimple_omp_for_combined_p (fd->for_stmt))
{
 remove_edge (e);
 e = NULLnullptr;
}
    else if (fd->collapse > 1)
{
 remove_edge (e);
 e = make_edge (cont_bb, collapse_bb, EDGE_TRUE_VALUE);
}
    else
e->flags = EDGE_TRUE_VALUE;
    if (e)
{
 e->probability = profile_probability::guessed_always ().apply_scale (7, 8);
 find_edge (cont_bb, l2_bb)->probability = e->probability.invert ();
}
    else
{
 e = find_edge (cont_bb, l2_bb);
 e->flags = EDGE_FALLTHRU;
}
    make_edge (l2_bb, l0_bb, EDGE_TRUE_VALUE);

    if (gimple_in_ssa_p (cfun(cfun + 0)))
{
 /* Add phis to the outer loop that connect to the phis in the inner,
    original loop, and move the loop entry value of the inner phi to
    the loop entry value of the outer phi.  */
 gphi_iterator psi;
 for (psi = gsi_start_phis (l3_bb); !gsi_end_p (psi); gsi_next (&psi))
   {
     location_t locus;
     gphi *nphi;
     gphi *exit_phi = psi.phi ();

     if (virtual_operand_p (gimple_phi_result (exit_phi)))
continue;

     edge l2_to_l3 = find_edge (l2_bb, l3_bb);
     tree exit_res = PHI_ARG_DEF_FROM_EDGE (exit_phi, l2_to_l3)gimple_phi_arg_def (((exit_phi)), ((l2_to_l3)->dest_idx));

     basic_block latch = BRANCH_EDGE (cont_bb)((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU ?
 (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(0)
])->dest;
     edge latch_to_l1 = find_edge (latch, l1_bb);
     gphi *inner_phi
= find_phi_with_arg_on_edge (exit_res, latch_to_l1);

     tree t = gimple_phi_result (exit_phi);
     tree new_res = copy_ssa_name (t, NULLnullptr);
     nphi = create_phi_node (new_res, l0_bb);

     edge l0_to_l1 = find_edge (l0_bb, l1_bb);
     t = PHI_ARG_DEF_FROM_EDGE (inner_phi, l0_to_l1)gimple_phi_arg_def (((inner_phi)), ((l0_to_l1)->dest_idx));
     locus = gimple_phi_arg_location_from_edge (inner_phi, l0_to_l1);
     edge entry_to_l0 = find_edge (entry_bb, l0_bb);
     add_phi_arg (nphi, t, entry_to_l0, locus);

     edge l2_to_l0 = find_edge (l2_bb, l0_bb);
     add_phi_arg (nphi, exit_res, l2_to_l0, UNKNOWN_LOCATION((location_t) 0));

     add_phi_arg (inner_phi, new_res, l0_to_l1, UNKNOWN_LOCATION((location_t) 0));
   }
}

    set_immediate_dominator (CDI_DOMINATORS, l2_bb,
	       recompute_dominator (CDI_DOMINATORS, l2_bb));
    set_immediate_dominator (CDI_DOMINATORS, l3_bb,
	       recompute_dominator (CDI_DOMINATORS, l3_bb));
    set_immediate_dominator (CDI_DOMINATORS, l0_bb,
	       recompute_dominator (CDI_DOMINATORS, l0_bb));
    set_immediate_dominator (CDI_DOMINATORS, l1_bb,
	       recompute_dominator (CDI_DOMINATORS, l1_bb));

    /* We enter expand_omp_for_generic with a loop.  This original loop may
have its own loop struct, or it may be part of an outer loop struct
(which may be the fake loop).  */
    class loop *outer_loop = entry_bb->loop_father;
    bool orig_loop_has_loop_struct = l1_bb->loop_father != outer_loop;

    add_bb_to_loop (l2_bb, outer_loop);

    /* We've added a new loop around the original loop.  Allocate the
corresponding loop struct.  */
    class loop *new_loop = alloc_loop ();
    new_loop->header = l0_bb;
    new_loop->latch = l2_bb;
    add_loop (new_loop, outer_loop);

    /* Allocate a loop structure for the original loop unless we already
had one.  */
    if (!orig_loop_has_loop_struct
 && !gimple_omp_for_combined_p (fd->for_stmt))
{
 class loop *orig_loop = alloc_loop ();
 orig_loop->header = l1_bb;
 /* The loop may have multiple latches.  */
 add_loop (orig_loop, new_loop);
}
  }
4785}

4787/* Helper function for expand_omp_for_static_nochunk.  If PTR is NULL,
 compute needed allocation size.  If !ALLOC of team allocations,
 if ALLOC of thread allocation.  SZ is the initial needed size for
 other purposes, ALLOC_ALIGN guaranteed alignment of allocation in bytes,
 CNT number of elements of each array, for !ALLOC this is
 omp_get_num_threads (), for ALLOC number of iterations handled by the
 current thread.  If PTR is non-NULL, it is the start of the allocation
 and this routine shall assign to OMP_CLAUSE_DECL (c) of those _scantemp_
 clauses pointers to the corresponding arrays.  */

4797static tree
4798expand_omp_scantemp_alloc (tree clauses, tree ptr, unsigned HOST_WIDE_INTlong sz,
	   unsigned HOST_WIDE_INTlong alloc_align, tree cnt,
	   gimple_stmt_iterator *gsi, bool alloc)
4801{
tree eltsz = NULL_TREE(tree) nullptr;
unsigned HOST_WIDE_INTlong preval = 0;
if (ptr && sz)
  ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr),fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4805, __FUNCTION__))->typed.type), ptr, size_int_kind (sz
, stk_sizetype) )
       ptr, size_int (sz))fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4805, __FUNCTION__))->typed.type), ptr, size_int_kind (sz
, stk_sizetype) );
for (tree c = clauses; c; c = OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4807, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4807, __FUNCTION__))->common.chain))
  if (OMP_CLAUSE_CODE (c)((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4808, __FUNCTION__, (OMP_CLAUSE))))->omp_clause.code == OMP_CLAUSE__SCANTEMP_
&& !OMP_CLAUSE__SCANTEMP__CONTROL (c)(((omp_clause_subcode_check ((c), (OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4809, __FUNCTION__)))->base.private_flag)
&& (!OMP_CLAUSE__SCANTEMP__ALLOC (c)((omp_clause_subcode_check ((c), (OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4810, __FUNCTION__))->base.public_flag)) != alloc)
    {
tree pointee_type = TREE_TYPE (TREE_TYPE (OMP_CLAUSE_DECL (c)))((contains_struct_check ((((contains_struct_check (((*(omp_clause_elt_check
 (((omp_clause_range_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4812, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4812, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4812, __FUNCTION__)))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4812, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4812, __FUNCTION__))->typed.type);
unsigned HOST_WIDE_INTlong al = TYPE_ALIGN_UNIT (pointee_type)((((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4813, __FUNCTION__))->type_common.align) ? ((unsigned)1)
 << (((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4813, __FUNCTION__))->type_common.align) - 1) : 0) / (8)
);
if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (pointee_type)((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4814, __FUNCTION__))->type_common.size_unit)))
 {
   unsigned HOST_WIDE_INTlong szl
     = tree_to_uhwi (TYPE_SIZE_UNIT (pointee_type)((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4817, __FUNCTION__))->type_common.size_unit));
   szl = least_bit_hwi (szl);
   if (szl)
     al = MIN (al, szl)((al) < (szl) ? (al) : (szl));
 }
if (ptr == NULL_TREE(tree) nullptr)
 {
   if (eltsz == NULL_TREE(tree) nullptr)
     eltsz = TYPE_SIZE_UNIT (pointee_type)((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4825, __FUNCTION__))->type_common.size_unit);
   else
     eltsz = size_binop (PLUS_EXPR, eltsz,size_binop_loc (((location_t) 0), PLUS_EXPR, eltsz, ((tree_class_check
 ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4828, __FUNCTION__))->type_common.size_unit))
		  TYPE_SIZE_UNIT (pointee_type))size_binop_loc (((location_t) 0), PLUS_EXPR, eltsz, ((tree_class_check
 ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4828, __FUNCTION__))->type_common.size_unit));
 }
if (preval == 0 && al <= alloc_align)
 {
   unsigned HOST_WIDE_INTlong diff = ROUND_UP (sz, al)(((sz) + (al) - 1) & ~((al) - 1)) - sz;
   sz += diff;
   if (diff && ptr)
     ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr),fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4835, __FUNCTION__))->typed.type), ptr, size_int_kind (diff
, stk_sizetype) )
		 ptr, size_int (diff))fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4835, __FUNCTION__))->typed.type), ptr, size_int_kind (diff
, stk_sizetype) );
 }
else if (al > preval)
 {
   if (ptr)
     {
ptr = fold_convert (pointer_sized_int_node, ptr)fold_convert_loc (((location_t) 0), global_trees[TI_POINTER_SIZED_TYPE
], ptr);
ptr = fold_build2 (PLUS_EXPR, pointer_sized_int_node, ptr,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_POINTER_SIZED_TYPE
], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE], al
 - 1) )
		   build_int_cst (pointer_sized_int_node,fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_POINTER_SIZED_TYPE
], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE], al
 - 1) )
				  al - 1))fold_build2_loc (((location_t) 0), PLUS_EXPR, global_trees[TI_POINTER_SIZED_TYPE
], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE], al
 - 1) );
ptr = fold_build2 (BIT_AND_EXPR, pointer_sized_int_node, ptr,fold_build2_loc (((location_t) 0), BIT_AND_EXPR, global_trees
[TI_POINTER_SIZED_TYPE], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE
], -(long) al) )
		   build_int_cst (pointer_sized_int_node,fold_build2_loc (((location_t) 0), BIT_AND_EXPR, global_trees
[TI_POINTER_SIZED_TYPE], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE
], -(long) al) )
				  -(HOST_WIDE_INT) al))fold_build2_loc (((location_t) 0), BIT_AND_EXPR, global_trees
[TI_POINTER_SIZED_TYPE], ptr, build_int_cst (global_trees[TI_POINTER_SIZED_TYPE
], -(long) al) );
ptr = fold_convert (ptr_type_node, ptr)fold_convert_loc (((location_t) 0), global_trees[TI_PTR_TYPE]
, ptr);
     }
   else
     sz += al - 1;
 }
if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (pointee_type)((tree_class_check ((pointee_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4854, __FUNCTION__))->type_common.size_unit)))
 preval = al;
else
 preval = 1;
if (ptr)
 {
   expand_omp_build_assign (gsi, OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4860, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4860, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4860, __FUNCTION__))), ptr, false);
   ptr = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4861, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4861, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4861, __FUNCTION__)));
   ptr = fold_build2 (POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr,fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4862, __FUNCTION__))->typed.type), ptr, size_binop_loc (
((location_t) 0), MULT_EXPR, cnt, ((tree_class_check ((pointee_type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4864, __FUNCTION__))->type_common.size_unit)) )
	       size_binop (MULT_EXPR, cnt,fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4862, __FUNCTION__))->typed.type), ptr, size_binop_loc (
((location_t) 0), MULT_EXPR, cnt, ((tree_class_check ((pointee_type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4864, __FUNCTION__))->type_common.size_unit)) )
			   TYPE_SIZE_UNIT (pointee_type)))fold_build2_loc (((location_t) 0), POINTER_PLUS_EXPR, ((contains_struct_check
 ((ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4862, __FUNCTION__))->typed.type), ptr, size_binop_loc (
((location_t) 0), MULT_EXPR, cnt, ((tree_class_check ((pointee_type
), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4864, __FUNCTION__))->type_common.size_unit)) );
 }
    }

if (ptr == NULL_TREE(tree) nullptr)
  {
    eltsz = size_binop (MULT_EXPR, eltsz, cnt)size_binop_loc (((location_t) 0), MULT_EXPR, eltsz, cnt);
    if (sz)
eltsz = size_binop (PLUS_EXPR, eltsz, size_int (sz))size_binop_loc (((location_t) 0), PLUS_EXPR, eltsz, size_int_kind
 (sz, stk_sizetype));
    return eltsz;
  }
else
  return ptr;
4877}

4879/* Return the last _looptemp_ clause if one has been created for
 lastprivate on distribute parallel for{, simd} or taskloop.
 FD is the loop data and INNERC should be the second _looptemp_
 clause (the one holding the end of the range).
 This is followed by collapse - 1 _looptemp_ clauses for the
 counts[1] and up, and for triangular loops followed by 4
 further _looptemp_ clauses (one for counts[0], one first_inner_iterations,
 one factor and one adjn1).  After this there is optionally one
 _looptemp_ clause that this function returns.  */

4889static tree
4890find_lastprivate_looptemp (struct omp_for_data *fd, tree innerc)
4891{
gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4892, __FUNCTION__), 0 : 0));
int count = fd->collapse - 1;
if (fd->non_rect
    && fd->last_nonrect == fd->first_nonrect + 1
    && !TYPE_UNSIGNED (TREE_TYPE (fd->loops[fd->last_nonrect].v))((tree_class_check ((((contains_struct_check ((fd->loops[fd
->last_nonrect].v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4896, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4896, __FUNCTION__))->base.u.bits.unsigned_flag))
  count += 4;
for (int i = 0; i < count; i++)
  {
    innerc = omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4900, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4900, __FUNCTION__))->common.chain),
		OMP_CLAUSE__LOOPTEMP_);
    gcc_assert (innerc)((void)(!(innerc) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4902, __FUNCTION__), 0 : 0));
  }
return omp_find_clause (OMP_CLAUSE_CHAIN (innerc)((contains_struct_check (((tree_check ((innerc), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4904, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4904, __FUNCTION__))->common.chain),
	  OMP_CLAUSE__LOOPTEMP_);
4906}

4908/* A subroutine of expand_omp_for.  Generate code for a parallel
 loop with static schedule and no specified chunk size.  Given
 parameters:

for (V = N1; V cond N2; V += STEP) BODY;

 where COND is "<" or ">", we generate pseudocode

if ((__typeof (V)) -1 > 0 && N2 cond N1) goto L2;
if (cond is <)
 adj = STEP - 1;
else
 adj = STEP + 1;
if ((__typeof (V)) -1 > 0 && cond is >)
 n = -(adj + N2 - N1) / -STEP;
else
 n = (adj + N2 - N1) / STEP;
q = n / nthreads;
tt = n % nthreads;
if (threadid < tt) goto L3; else goto L4;
  L3:
tt = 0;
q = q + 1;
  L4:
s0 = q * threadid + tt;
e0 = s0 + q;
V = s0 * STEP + N1;
if (s0 >= e0) goto L2; else goto L0;
  L0:
e = e0 * STEP + N1;
  L1:
BODY;
V += STEP;
if (V cond e) goto L1;
  L2:
4943*/

4945static void
4946expand_omp_for_static_nochunk (struct omp_region *region,
	       struct omp_for_data *fd,
	       gimple *inner_stmt)
4949{
tree n, q, s0, e0, e, t, tt, nthreads = NULL_TREE(tree) nullptr, threadid;
tree type, itype, vmain, vback;
basic_block entry_bb, second_bb, third_bb, exit_bb, seq_start_bb;
basic_block body_bb, cont_bb, collapse_bb = NULLnullptr;
basic_block fin_bb, fourth_bb = NULLnullptr, fifth_bb = NULLnullptr, sixth_bb = NULLnullptr;
basic_block exit1_bb = NULLnullptr, exit2_bb = NULLnullptr, exit3_bb = NULLnullptr;
gimple_stmt_iterator gsi, gsip;
edge ep;
bool broken_loop = region->cont == NULLnullptr;
tree *counts = NULLnullptr;
tree n1, n2, step;
tree reductions = NULL_TREE(tree) nullptr;
tree cond_var = NULL_TREE(tree) nullptr, condtemp = NULL_TREE(tree) nullptr;

itype = type = TREE_TYPE (fd->loop.v)((contains_struct_check ((fd->loop.v), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4964, __FUNCTION__))->typed.type);
if (POINTER_TYPE_P (type)(((enum tree_code) (type)->base.code) == POINTER_TYPE || (
(enum tree_code) (type)->base.code) == REFERENCE_TYPE))
  itype = signed_type_for (type);

entry_bb = region->entry;
cont_bb = region->cont;
gcc_assert (EDGE_COUNT (entry_bb->succs) == 2)((void)(!(vec_safe_length (entry_bb->succs) == 2) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4970, __FUNCTION__), 0 : 0));
fin_bb = BRANCH_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(1)] : (*((entry_bb))->succs)
[(0)])->dest;
gcc_assert (broken_loop((void)(!(broken_loop || (fin_bb == ((*((cont_bb))->succs)
[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->succs
)[(0)] : (*((cont_bb))->succs)[(1)])->dest)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4973, __FUNCTION__), 0 : 0))
     || (fin_bb == FALLTHRU_EDGE (cont_bb)->dest))((void)(!(broken_loop || (fin_bb == ((*((cont_bb))->succs)
[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->succs
)[(0)] : (*((cont_bb))->succs)[(1)])->dest)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4973, __FUNCTION__), 0 : 0));
seq_start_bb = split_edge (FALLTHRU_EDGE (entry_bb)((*((entry_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((entry_bb))->succs)[(0)] : (*((entry_bb))->succs)
[(1)]));
body_bb = single_succ (seq_start_bb);
if (!broken_loop)
  {
    gcc_assert (BRANCH_EDGE (cont_bb)->dest == body_bb((void)(!(((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(
0)])->dest == body_bb || single_succ (((*((cont_bb))->succs
)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->succs
)[(1)] : (*((cont_bb))->succs)[(0)])->dest) == body_bb)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4979, __FUNCTION__), 0 : 0))
  || single_succ (BRANCH_EDGE (cont_bb)->dest) == body_bb)((void)(!(((*((cont_bb))->succs)[(0)]->flags & EDGE_FALLTHRU
 ? (*((cont_bb))->succs)[(1)] : (*((cont_bb))->succs)[(
0)])->dest == body_bb || single_succ (((*((cont_bb))->succs
)[(0)]->flags & EDGE_FALLTHRU ? (*((cont_bb))->succs
)[(1)] : (*((cont_bb))->succs)[(0)])->dest) == body_bb)
 ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4979, __FUNCTION__), 0 : 0));
    gcc_assert (EDGE_COUNT (cont_bb->succs) == 2)((void)(!(vec_safe_length (cont_bb->succs) == 2) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4980, __FUNCTION__), 0 : 0));
  }
exit_bb = region->exit;

/* Iteration space partitioning goes in ENTRY_BB.  */
gsi = gsi_last_nondebug_bb (entry_bb);
gcc_assert (gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR)((void)(!(gimple_code (gsi_stmt (gsi)) == GIMPLE_OMP_FOR) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 4986, __FUNCTION__), 0 : 0));
gsip = gsi;
gsi_prev (&gsip);

if (fd->collapse > 1)
  {
    int first_zero_iter = -1, dummy = -1;
    basic_block l2_dom_bb = NULLnullptr, dummy_bb = NULLnullptr;

    counts = XALLOCAVEC (tree, fd->collapse)((tree *) __builtin_alloca(sizeof (tree) * (fd->collapse))
);
    expand_omp_for_init_counts (fd, &gsi, entry_bb, counts,
		  fin_bb, first_zero_iter,
		  dummy_bb, dummy, l2_dom_bb);
    t = NULL_TREE(tree) nullptr;
  }
else if (gimple_omp_for_combined_into_p (fd->for_stmt))
  t = integer_one_nodeglobal_trees[TI_INTEGER_ONE];
else
  t = fold_binary (fd->loop.cond_code, boolean_type_node,fold_binary_loc (((location_t) 0), fd->loop.cond_code, global_trees
[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t) 0), type, fd
->loop.n1), fold_convert_loc (((location_t) 0), type, fd->
loop.n2))
     fold_convert (type, fd->loop.n1),fold_binary_loc (((location_t) 0), fd->loop.cond_code, global_trees
[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t) 0), type, fd
->loop.n1), fold_convert_loc (((location_t) 0), type, fd->
loop.n2))
     fold_convert (type, fd->loop.n2))fold_binary_loc (((location_t) 0), fd->loop.cond_code, global_trees
[TI_BOOLEAN_TYPE], fold_convert_loc (((location_t) 0), type, fd
->loop.n1), fold_convert_loc (((location_t) 0), type, fd->
loop.n2));
if (fd->collapse == 1
    && TYPE_UNSIGNED (type)((tree_class_check ((type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5008, __FUNCTION__))->base.u.bits.unsigned_flag)
    && (t == NULL_TREE(tree) nullptr || !integer_onep (t)))
  {
    n1 = fold_convert (type, unshare_expr (fd->loop.n1))fold_convert_loc (((location_t) 0), type, unshare_expr (fd->
loop.n1));
    n1 = force_gimple_operand_gsi (&gsi, n1, true, NULL_TREE(tree) nullptr,
		     true, GSI_SAME_STMT);
    n2 = fold_convert (type, unshare_expr (fd->loop.n2))fold_convert_loc (((location_t) 0), type, unshare_expr (fd->
loop.n2));
    n2 = force_gimple_operand_gsi (&gsi, n2, true, NULL_TREE(tree) nullptr,
		     true, GSI_SAME_STMT);
    gcond *cond_stmt = expand_omp_build_cond (&gsi, fd->loop.cond_code,
				n1, n2);
    ep = split_block (entry_bb, cond_stmt);
    ep->flags = EDGE_TRUE_VALUE;
    entry_bb = ep->dest;
    ep->probability = profile_probability::very_likely ();
    ep = make_edge (ep->src, fin_bb, EDGE_FALSE_VALUE);
    ep->probability = profile_probability::very_unlikely ();
    if (gimple_in_ssa_p (cfun(cfun + 0)))
{
 int dest_idx = find_edge (entry_bb, fin_bb)->dest_idx;
 for (gphi_iterator gpi = gsi_start_phis (fin_bb);
      !gsi_end_p (gpi); gsi_next (&gpi))
   {
     gphi *phi = gpi.phi ();
     add_phi_arg (phi, gimple_phi_arg_def (phi, dest_idx),
	   ep, UNKNOWN_LOCATION((location_t) 0));
   }
}
    gsi = gsi_last_bb (entry_bb);
  }

if (fd->lastprivate_conditional)
  {
    tree clauses = gimple_omp_for_clauses (fd->for_stmt);
    tree c = omp_find_clause (clauses, OMP_CLAUSE__CONDTEMP_);
    if (fd->have_pointer_condtemp)
condtemp = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5044, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5044, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5044, __FUNCTION__)));
    c = omp_find_clause (OMP_CLAUSE_CHAIN (c)((contains_struct_check (((tree_check ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5045, __FUNCTION__, (OMP_CLAUSE)))), (TS_COMMON), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5045, __FUNCTION__))->common.chain), OMP_CLAUSE__CONDTEMP_);
    cond_var = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5046, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE_PRIVATE), (
OMP_CLAUSE__SCANTEMP_), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5046, __FUNCTION__))), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5046, __FUNCTION__)));
  }
if (fd->have_reductemp
    /* For scan, we don't want to reinitialize condtemp before the
second loop.  */
    || (fd->have_pointer_condtemp && !fd->have_scantemp)
    || fd->have_nonctrl_scantemp)
  {
    tree t1 = build_int_cst (long_integer_type_nodeinteger_types[itk_long], 0);
    tree t2 = build_int_cst (long_integer_type_nodeinteger_types[itk_long], 1);
    tree t3 = build_int_cstu (long_integer_type_nodeinteger_types[itk_long],
		(HOST_WIDE_INT_1U1UL << 31) + 1);
    tree clauses = gimple_omp_for_clauses (fd->for_stmt);
    gimple_stmt_iterator gsi2 = gsi_none ();
    gimple *g = NULLnullptr;
    tree mem = null_pointer_nodeglobal_trees[TI_NULL_POINTER], memv = NULL_TREE(tree) nullptr;
    unsigned HOST_WIDE_INTlong condtemp_sz = 0;
    unsigned HOST_WIDE_INTlong alloc_align = 0;
    if (fd->have_reductemp)
{
 gcc_assert (!fd->have_nonctrl_scantemp)((void)(!(!fd->have_nonctrl_scantemp) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5066, __FUNCTION__), 0 : 0));
 tree c = omp_find_clause (clauses, OMP_CLAUSE__REDUCTEMP_);
 reductions = OMP_CLAUSE_DECL (c)(*(omp_clause_elt_check (((omp_clause_range_check (((tree_check
 ((c), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/omp-expand.cc"
, 5068, __FUNCTION__, (OMP_CLAUSE)))), (OMP_CLAUSE