/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc

Bug Summary

File:	build/gcc/tree-vect-data-refs.cc
Warning:	line 4244, column 24 Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-suse-linux -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name tree-vect-data-refs.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-jELz2t.plist -x c++ /buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc

/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc

→

1/* Data References Analysis and Manipulation Utilities for Vectorization.
 Copyright (C) 2003-2023 Free Software Foundation, Inc.
 Contributed by Dorit Naishlos <dorit@il.ibm.com>
 and Ira Rosen <irar@il.ibm.com>

6This file is part of GCC.

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

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

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

22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "backend.h"
26#include "target.h"
27#include "rtl.h"
28#include "tree.h"
29#include "gimple.h"
30#include "predict.h"
31#include "memmodel.h"
32#include "tm_p.h"
33#include "ssa.h"
34#include "optabs-tree.h"
35#include "cgraph.h"
36#include "dumpfile.h"
37#include "alias.h"
38#include "fold-const.h"
39#include "stor-layout.h"
40#include "tree-eh.h"
41#include "gimplify.h"
42#include "gimple-iterator.h"
43#include "gimplify-me.h"
44#include "tree-ssa-loop-ivopts.h"
45#include "tree-ssa-loop-manip.h"
46#include "tree-ssa-loop.h"
47#include "cfgloop.h"
48#include "tree-scalar-evolution.h"
49#include "tree-vectorizer.h"
50#include "expr.h"
51#include "builtins.h"
52#include "tree-cfg.h"
53#include "tree-hash-traits.h"
54#include "vec-perm-indices.h"
55#include "internal-fn.h"
56#include "gimple-fold.h"

58/* Return true if load- or store-lanes optab OPTAB is implemented for
 COUNT vectors of type VECTYPE.  NAME is the name of OPTAB.  */

61static bool
62vect_lanes_optab_supported_p (const char *name, convert_optab optab,
	      tree vectype, unsigned HOST_WIDE_INTlong count)
64{
machine_mode mode, array_mode;
bool limit_p;

mode = TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 68, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (vectype) : (vectype)->type_common.mode);
if (!targetm.array_mode (mode, count).exists (&array_mode))
  {
    poly_uint64 bits = count * GET_MODE_BITSIZE (mode);
    limit_p = !targetm.array_mode_supported_p (mode, count);
    if (!int_mode_for_size (bits, limit_p).exists (&array_mode))
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	     "no array mode for %s[%wu]\n",
	     GET_MODE_NAME (mode)mode_name[mode], count);
 return false;
}
  }

if (convert_optab_handler (optab, array_mode, mode) == CODE_FOR_nothing)
  {
    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                       "cannot use %s<%s><%s>\n", name,
                       GET_MODE_NAME (array_mode)mode_name[array_mode], GET_MODE_NAME (mode)mode_name[mode]);
    return false;
  }

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                   "can use %s<%s><%s>\n", name, GET_MODE_NAME (array_mode)mode_name[array_mode],
                   GET_MODE_NAME (mode)mode_name[mode]);

return true;
98}


101/* Return the smallest scalar part of STMT_INFO.
 This is used to determine the vectype of the stmt.  We generally set the
 vectype according to the type of the result (lhs).  For stmts whose
 result-type is different than the type of the arguments (e.g., demotion,
 promotion), vectype will be reset appropriately (later).  Note that we have
 to visit the smallest datatype in this function, because that determines the
 VF.  If the smallest datatype in the loop is present only as the rhs of a
 promotion operation - we'd miss it.
 Such a case, where a variable of this datatype does not appear in the lhs
 anywhere in the loop, can only occur if it's an invariant: e.g.:
 'int_x = (int) short_inv', which we'd expect to have been optimized away by
 invariant motion.  However, we cannot rely on invariant motion to always
 take invariants out of the loop, and so in the case of promotion we also
 have to check the rhs.
 LHS_SIZE_UNIT and RHS_SIZE_UNIT contain the sizes of the corresponding
 types.  */

118tree
119vect_get_smallest_scalar_type (stmt_vec_info stmt_info, tree scalar_type)
120{
HOST_WIDE_INTlong lhs, rhs;

/* During the analysis phase, this function is called on arbitrary
   statements that might not have scalar results.  */
if (!tree_fits_uhwi_p (TYPE_SIZE_UNIT (scalar_type)((tree_class_check ((scalar_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 125, __FUNCTION__))->type_common.size_unit)))
  return scalar_type;

lhs = rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((scalar_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 128, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 128, __FUNCTION__)));

gassign *assign = dyn_cast <gassign *> (stmt_info->stmt);
if (assign)
  {
    scalar_type = TREE_TYPE (gimple_assign_lhs (assign))((contains_struct_check ((gimple_assign_lhs (assign)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 133, __FUNCTION__))->typed.type);
    if (gimple_assign_cast_p (assign)
 || gimple_assign_rhs_code (assign) == DOT_PROD_EXPR
 || gimple_assign_rhs_code (assign) == WIDEN_SUM_EXPR
 || gimple_assign_rhs_code (assign) == WIDEN_MULT_EXPR
 || gimple_assign_rhs_code (assign) == WIDEN_LSHIFT_EXPR
 || gimple_assign_rhs_code (assign) == WIDEN_PLUS_EXPR
 || gimple_assign_rhs_code (assign) == WIDEN_MINUS_EXPR
 || gimple_assign_rhs_code (assign) == FLOAT_EXPR)
{
 tree rhs_type = TREE_TYPE (gimple_assign_rhs1 (assign))((contains_struct_check ((gimple_assign_rhs1 (assign)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 143, __FUNCTION__))->typed.type);

 rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((rhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 145, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 145, __FUNCTION__)));
 if (rhs < lhs)
   scalar_type = rhs_type;
}
  }
else if (gcall *call = dyn_cast <gcall *> (stmt_info->stmt))
  {
    unsigned int i = 0;
    if (gimple_call_internal_p (call))
{
 internal_fn ifn = gimple_call_internal_fn (call);
 if (internal_load_fn_p (ifn))
   /* For loads the LHS type does the trick.  */
   i = ~0U;
 else if (internal_store_fn_p (ifn))
   {
     /* For stores use the tyep of the stored value.  */
     i = internal_fn_stored_value_index (ifn);
     scalar_type = TREE_TYPE (gimple_call_arg (call, i))((contains_struct_check ((gimple_call_arg (call, i)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 163, __FUNCTION__))->typed.type);
     i = ~0U;
   }
 else if (internal_fn_mask_index (ifn) == 0)
   i = 1;
}
    if (i < gimple_call_num_args (call))
{
 tree rhs_type = TREE_TYPE (gimple_call_arg (call, i))((contains_struct_check ((gimple_call_arg (call, i)), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 171, __FUNCTION__))->typed.type);
 if (tree_fits_uhwi_p (TYPE_SIZE_UNIT (rhs_type)((tree_class_check ((rhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 172, __FUNCTION__))->type_common.size_unit)))
   {
     rhs = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (rhs_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((rhs_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 174, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 174, __FUNCTION__)));
     if (rhs < lhs)
scalar_type = rhs_type;
   }
}
  }

return scalar_type;
182}


185/* Insert DDR into LOOP_VINFO list of ddrs that may alias and need to be
 tested at run-time.  Return TRUE if DDR was successfully inserted.
 Return false if versioning is not supported.  */

189static opt_result
190vect_mark_for_runtime_alias_test (ddr_p ddr, loop_vec_info loop_vinfo)
191{
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;

if ((unsigned) param_vect_max_version_for_alias_checksglobal_options.x_param_vect_max_version_for_alias_checks == 0)
  return opt_result::failure_at (vect_location,
		   "will not create alias checks, as"
		   " --param vect-max-version-for-alias-checks"
		   " == 0\n");

opt_result res
  = runtime_alias_check_p (ddr, loop,
	     optimize_loop_nest_for_speed_p (loop));
if (!res)
  return res;

LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo)(loop_vinfo)->may_alias_ddrs.safe_push (ddr);
return opt_result::success ();
208}

210/* Record that loop LOOP_VINFO needs to check that VALUE is nonzero.  */

212static void
213vect_check_nonzero_value (loop_vec_info loop_vinfo, tree value)
214{
const vec<tree> &checks = LOOP_VINFO_CHECK_NONZERO (loop_vinfo)(loop_vinfo)->check_nonzero;
for (unsigned int i = 0; i < checks.length(); ++i)
  if (checks[i] == value)
    return;

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
     "need run-time check that %T is nonzero\n",
     value);
LOOP_VINFO_CHECK_NONZERO (loop_vinfo)(loop_vinfo)->check_nonzero.safe_push (value);
225}

227/* Return true if we know that the order of vectorized DR_INFO_A and
 vectorized DR_INFO_B will be the same as the order of DR_INFO_A and
 DR_INFO_B.  At least one of the accesses is a write.  */

231static bool
232vect_preserves_scalar_order_p (dr_vec_info *dr_info_a, dr_vec_info *dr_info_b)
233{
stmt_vec_info stmtinfo_a = dr_info_a->stmt;
stmt_vec_info stmtinfo_b = dr_info_b->stmt;

/* Single statements are always kept in their original order.  */
if (!STMT_VINFO_GROUPED_ACCESS (stmtinfo_a)((stmtinfo_a)->dr_aux.dr && (((void)(!((stmtinfo_a
)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 238, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
))
    && !STMT_VINFO_GROUPED_ACCESS (stmtinfo_b)((stmtinfo_b)->dr_aux.dr && (((void)(!((stmtinfo_b
)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 239, __FUNCTION__), 0 : 0)), (stmtinfo_b)->first_element
)))
  return true;

/* STMT_A and STMT_B belong to overlapping groups.  All loads are
   emitted at the position of the first scalar load.
   Stores in a group are emitted at the position of the last scalar store.
   Compute that position and check whether the resulting order matches
   the current one.  */
stmt_vec_info il_a = DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 247, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
);
if (il_a)
  {
    if (DR_IS_WRITE (STMT_VINFO_DATA_REF (stmtinfo_a))(!(((stmtinfo_a)->dr_aux.dr + 0))->is_read))
for (stmt_vec_info s = DR_GROUP_NEXT_ELEMENT (il_a)(((void)(!((il_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 251, __FUNCTION__), 0 : 0)), (il_a)->next_element); s;
    s = DR_GROUP_NEXT_ELEMENT (s)(((void)(!((s)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 252, __FUNCTION__), 0 : 0)), (s)->next_element))
 il_a = get_later_stmt (il_a, s);
    else /* DR_IS_READ */
for (stmt_vec_info s = DR_GROUP_NEXT_ELEMENT (il_a)(((void)(!((il_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 255, __FUNCTION__), 0 : 0)), (il_a)->next_element); s;
    s = DR_GROUP_NEXT_ELEMENT (s)(((void)(!((s)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 256, __FUNCTION__), 0 : 0)), (s)->next_element))
 if (get_later_stmt (il_a, s) == il_a)
   il_a = s;
  }
else
  il_a = stmtinfo_a;
stmt_vec_info il_b = DR_GROUP_FIRST_ELEMENT (stmtinfo_b)(((void)(!((stmtinfo_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 262, __FUNCTION__), 0 : 0)), (stmtinfo_b)->first_element
);
if (il_b)
  {
    if (DR_IS_WRITE (STMT_VINFO_DATA_REF (stmtinfo_b))(!(((stmtinfo_b)->dr_aux.dr + 0))->is_read))
for (stmt_vec_info s = DR_GROUP_NEXT_ELEMENT (il_b)(((void)(!((il_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 266, __FUNCTION__), 0 : 0)), (il_b)->next_element); s;
    s = DR_GROUP_NEXT_ELEMENT (s)(((void)(!((s)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 267, __FUNCTION__), 0 : 0)), (s)->next_element))
 il_b = get_later_stmt (il_b, s);
    else /* DR_IS_READ */
for (stmt_vec_info s = DR_GROUP_NEXT_ELEMENT (il_b)(((void)(!((il_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 270, __FUNCTION__), 0 : 0)), (il_b)->next_element); s;
    s = DR_GROUP_NEXT_ELEMENT (s)(((void)(!((s)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 271, __FUNCTION__), 0 : 0)), (s)->next_element))
 if (get_later_stmt (il_b, s) == il_b)
   il_b = s;
  }
else
  il_b = stmtinfo_b;
bool a_after_b = (get_later_stmt (stmtinfo_a, stmtinfo_b) == stmtinfo_a);
return (get_later_stmt (il_a, il_b) == il_a) == a_after_b;
279}

281/* A subroutine of vect_analyze_data_ref_dependence.  Handle
 DDR_COULD_BE_INDEPENDENT_P ddr DDR that has a known set of dependence
 distances.  These distances are conservatively correct but they don't
 reflect a guaranteed dependence.

 Return true if this function does all the work necessary to avoid
 an alias or false if the caller should use the dependence distances
 to limit the vectorization factor in the usual way.  LOOP_DEPTH is
 the depth of the loop described by LOOP_VINFO and the other arguments
 are as for vect_analyze_data_ref_dependence.  */

292static bool
293vect_analyze_possibly_independent_ddr (data_dependence_relation *ddr,
		       loop_vec_info loop_vinfo,
		       int loop_depth, unsigned int *max_vf)
296{
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;
for (lambda_vector &dist_v : DDR_DIST_VECTS (ddr)((ddr)->dist_vects))
  {
    int dist = dist_v[loop_depth];
    if (dist != 0 && !(dist > 0 && DDR_REVERSED_P (ddr)(ddr)->reversed_p))
{
 /* If the user asserted safelen >= DIST consecutive iterations
    can be executed concurrently, assume independence.

    ??? An alternative would be to add the alias check even
    in this case, and vectorize the fallback loop with the
    maximum VF set to safelen.  However, if the user has
    explicitly given a length, it's less likely that that
    would be a win.  */
 if (loop->safelen >= 2 && abs_hwi (dist) <= loop->safelen)
   {
     if ((unsigned int) loop->safelen < *max_vf)
*max_vf = loop->safelen;
     LOOP_VINFO_NO_DATA_DEPENDENCIES (loop_vinfo)(loop_vinfo)->no_data_dependencies = false;
     continue;
   }

 /* For dependence distances of 2 or more, we have the option
    of limiting VF or checking for an alias at runtime.
    Prefer to check at runtime if we can, to avoid limiting
    the VF unnecessarily when the bases are in fact independent.

    Note that the alias checks will be removed if the VF ends up
    being small enough.  */
 dr_vec_info *dr_info_a = loop_vinfo->lookup_dr (DDR_A (ddr)(ddr)->a);
 dr_vec_info *dr_info_b = loop_vinfo->lookup_dr (DDR_B (ddr)(ddr)->b);
 return (!STMT_VINFO_GATHER_SCATTER_P (dr_info_a->stmt)(dr_info_a->stmt)->gather_scatter_p
  && !STMT_VINFO_GATHER_SCATTER_P (dr_info_b->stmt)(dr_info_b->stmt)->gather_scatter_p
  && vect_mark_for_runtime_alias_test (ddr, loop_vinfo));
}
  }
return true;
334}


337/* Function vect_analyze_data_ref_dependence.

 FIXME: I needed to change the sense of the returned flag.

 Return FALSE if there (might) exist a dependence between a memory-reference
 DRA and a memory-reference DRB.  When versioning for alias may check a
 dependence at run-time, return TRUE.  Adjust *MAX_VF according to
 the data dependence.  */

346static opt_result
347vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr,
		  loop_vec_info loop_vinfo,
		  unsigned int *max_vf)
350{
unsigned int i;
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;
struct data_reference *dra = DDR_A (ddr)(ddr)->a;
struct data_reference *drb = DDR_B (ddr)(ddr)->b;
dr_vec_info *dr_info_a = loop_vinfo->lookup_dr (dra);
dr_vec_info *dr_info_b = loop_vinfo->lookup_dr (drb);
stmt_vec_info stmtinfo_a = dr_info_a->stmt;
stmt_vec_info stmtinfo_b = dr_info_b->stmt;
lambda_vector dist_v;
unsigned int loop_depth;

/* If user asserted safelen consecutive iterations can be
   executed concurrently, assume independence.  */
auto apply_safelen = [&]()
  {
    if (loop->safelen >= 2)
{
 if ((unsigned int) loop->safelen < *max_vf)
   *max_vf = loop->safelen;
 LOOP_VINFO_NO_DATA_DEPENDENCIES (loop_vinfo)(loop_vinfo)->no_data_dependencies = false;
 return true;
}
    return false;
  };

/* In loop analysis all data references should be vectorizable.  */
if (!STMT_VINFO_VECTORIZABLE (stmtinfo_a)(stmtinfo_a)->vectorizable
    || !STMT_VINFO_VECTORIZABLE (stmtinfo_b)(stmtinfo_b)->vectorizable)
  gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 379, __FUNCTION__));

/* Independent data accesses.  */
if (DDR_ARE_DEPENDENT (ddr)(ddr)->are_dependent == chrec_knownglobal_trees[TI_CHREC_KNOWN])
  return opt_result::success ();

if (dra == drb
    || (DR_IS_READ (dra)(dra)->is_read && DR_IS_READ (drb)(drb)->is_read))
  return opt_result::success ();

/* We do not have to consider dependences between accesses that belong
   to the same group, unless the stride could be smaller than the
   group size.  */
if (DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 392, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
)
    && (DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 393, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
)
 == DR_GROUP_FIRST_ELEMENT (stmtinfo_b)(((void)(!((stmtinfo_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 394, __FUNCTION__), 0 : 0)), (stmtinfo_b)->first_element
))
    && !STMT_VINFO_STRIDED_P (stmtinfo_a)(stmtinfo_a)->strided_p)
  return opt_result::success ();

/* Even if we have an anti-dependence then, as the vectorized loop covers at
   least two scalar iterations, there is always also a true dependence.
   As the vectorizer does not re-order loads and stores we can ignore
   the anti-dependence if TBAA can disambiguate both DRs similar to the
   case with known negative distance anti-dependences (positive
   distance anti-dependences would violate TBAA constraints).  */
if (((DR_IS_READ (dra)(dra)->is_read && DR_IS_WRITE (drb)(!(drb)->is_read))
     || (DR_IS_WRITE (dra)(!(dra)->is_read) && DR_IS_READ (drb)(drb)->is_read))
    && !alias_sets_conflict_p (get_alias_set (DR_REF (dra)(dra)->ref),
		 get_alias_set (DR_REF (drb)(drb)->ref)))
  return opt_result::success ();

if (STMT_VINFO_GATHER_SCATTER_P (stmtinfo_a)(stmtinfo_a)->gather_scatter_p
    || STMT_VINFO_GATHER_SCATTER_P (stmtinfo_b)(stmtinfo_b)->gather_scatter_p)
  {
    if (apply_safelen ())
return opt_result::success ();

    return opt_result::failure_at
(stmtinfo_a->stmt,
"possible alias involving gather/scatter between %T and %T\n",
DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);
  }

/* Unknown data dependence.  */
if (DDR_ARE_DEPENDENT (ddr)(ddr)->are_dependent == chrec_dont_knowglobal_trees[TI_CHREC_DONT_KNOW])
  {
    if (apply_safelen ())
return opt_result::success ();

    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, stmtinfo_a->stmt,
	 "versioning for alias required: "
	 "can't determine dependence between %T and %T\n",
	 DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);

    /* Add to list of ddrs that need to be tested at run-time.  */
    return vect_mark_for_runtime_alias_test (ddr, loop_vinfo);
  }

/* Known data dependence.  */
if (DDR_NUM_DIST_VECTS (ddr)(((ddr)->dist_vects).length ()) == 0)
  {
    if (apply_safelen ())
return opt_result::success ();

    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, stmtinfo_a->stmt,
	 "versioning for alias required: "
	 "bad dist vector for %T and %T\n",
	 DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);
    /* Add to list of ddrs that need to be tested at run-time.  */
    return vect_mark_for_runtime_alias_test (ddr, loop_vinfo);
  }

loop_depth = index_in_loop_nest (loop->num, DDR_LOOP_NEST (ddr)(ddr)->loop_nest);

if (DDR_COULD_BE_INDEPENDENT_P (ddr)(ddr)->could_be_independent_p
    && vect_analyze_possibly_independent_ddr (ddr, loop_vinfo,
				loop_depth, max_vf))
  return opt_result::success ();

FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr), i, dist_v)for (i = 0; (((ddr)->dist_vects)).iterate ((i), &(dist_v
)); ++(i))
  {
    int dist = dist_v[loop_depth];

    if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
                       "dependence distance  = %d.\n", dist);

    if (dist == 0)
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "dependence distance == 0 between %T and %T\n",
	     DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);

 /* When we perform grouped accesses and perform implicit CSE
    by detecting equal accesses and doing disambiguation with
    runtime alias tests like for
       .. = a[i];
.. = a[i+1];
a[i] = ..;
a[i+1] = ..;
*p = ..;
.. = a[i];
.. = a[i+1];
    where we will end up loading { a[i], a[i+1] } once, make
    sure that inserting group loads before the first load and
    stores after the last store will do the right thing.
    Similar for groups like
       a[i] = ...;
... = a[i];
a[i+1] = ...;
    where loads from the group interleave with the store.  */
 if (!vect_preserves_scalar_order_p (dr_info_a, dr_info_b))
   return opt_result::failure_at (stmtinfo_a->stmt,
			   "READ_WRITE dependence"
			   " in interleaving.\n");

 if (loop->safelen < 2)
   {
     tree indicator = dr_zero_step_indicator (dra);
     if (!indicator || integer_zerop (indicator))
return opt_result::failure_at (stmtinfo_a->stmt,
			       "access also has a zero step\n");
     else if (TREE_CODE (indicator)((enum tree_code) (indicator)->base.code) != INTEGER_CST)
vect_check_nonzero_value (loop_vinfo, indicator);
   }
 continue;
}

    if (dist > 0 && DDR_REVERSED_P (ddr)(ddr)->reversed_p)
{
 /* If DDR_REVERSED_P the order of the data-refs in DDR was
    reversed (to make distance vector positive), and the actual
    distance is negative.  */
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
                    "dependence distance negative.\n");
 /* When doing outer loop vectorization, we need to check if there is
    a backward dependence at the inner loop level if the dependence
    at the outer loop is reversed.  See PR81740.  */
 if (nested_in_vect_loop_p (loop, stmtinfo_a)
     || nested_in_vect_loop_p (loop, stmtinfo_b))
   {
     unsigned inner_depth = index_in_loop_nest (loop->inner->num,
					 DDR_LOOP_NEST (ddr)(ddr)->loop_nest);
     if (dist_v[inner_depth] < 0)
return opt_result::failure_at (stmtinfo_a->stmt,
			       "not vectorized, dependence "
			       "between data-refs %T and %T\n",
			       DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);
   }
 /* Record a negative dependence distance to later limit the
    amount of stmt copying / unrolling we can perform.
    Only need to handle read-after-write dependence.  */
 if (DR_IS_READ (drb)(drb)->is_read
     && (STMT_VINFO_MIN_NEG_DIST (stmtinfo_b)(stmtinfo_b)->min_neg_dist == 0
  || STMT_VINFO_MIN_NEG_DIST (stmtinfo_b)(stmtinfo_b)->min_neg_dist > (unsigned)dist))
   STMT_VINFO_MIN_NEG_DIST (stmtinfo_b)(stmtinfo_b)->min_neg_dist = dist;
 continue;
}

    unsigned int abs_dist = abs (dist);
    if (abs_dist >= 2 && abs_dist < *max_vf)
{
 /* The dependence distance requires reduction of the maximal
    vectorization factor.  */
 *max_vf = abs_dist;
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
                    "adjusting maximal vectorization factor to %i\n",
                    *max_vf);
}

    if (abs_dist >= *max_vf)
{
 /* Dependence distance does not create dependence, as far as
    vectorization is concerned, in this case.  */
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
                    "dependence distance >= VF.\n");
 continue;
}

    return opt_result::failure_at (stmtinfo_a->stmt,
		     "not vectorized, possible dependence "
		     "between data-refs %T and %T\n",
		     DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);
  }

return opt_result::success ();
571}

573/* Function vect_analyze_data_ref_dependences.

 Examine all the data references in the loop, and make sure there do not
 exist any data dependences between them.  Set *MAX_VF according to
 the maximum vectorization factor the data dependences allow.  */

579opt_result
580vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo,
		   unsigned int *max_vf)
582{
unsigned int i;
struct data_dependence_relation *ddr;

DUMP_VECT_SCOPE ("vect_analyze_data_ref_dependences")auto_dump_scope scope ("vect_analyze_data_ref_dependences", vect_location
);

if (!LOOP_VINFO_DDRS (loop_vinfo)(loop_vinfo)->shared->ddrs.exists ())
  {
    LOOP_VINFO_DDRS (loop_vinfo)(loop_vinfo)->shared->ddrs
.create (LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs.length ()
 * LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs.length ());
    /* We do not need read-read dependences.  */
    bool res = compute_all_dependences (LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs,
			  &LOOP_VINFO_DDRS (loop_vinfo)(loop_vinfo)->shared->ddrs,
			  LOOP_VINFO_LOOP_NEST (loop_vinfo)(loop_vinfo)->shared->loop_nest,
			  false);
    gcc_assert (res)((void)(!(res) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 598, __FUNCTION__), 0 : 0));
  }

LOOP_VINFO_NO_DATA_DEPENDENCIES (loop_vinfo)(loop_vinfo)->no_data_dependencies = true;

/* For epilogues we either have no aliases or alias versioning
   was applied to original loop.  Therefore we may just get max_vf
   using VF of original loop.  */
if (LOOP_VINFO_EPILOGUE_P (loop_vinfo)((loop_vinfo)->orig_loop_info != nullptr))
  *max_vf = LOOP_VINFO_ORIG_MAX_VECT_FACTOR (loop_vinfo)(((loop_vinfo)->orig_loop_info)->max_vectorization_factor
);
else
  FOR_EACH_VEC_ELT (LOOP_VINFO_DDRS (loop_vinfo), i, ddr)for (i = 0; ((loop_vinfo)->shared->ddrs).iterate ((i), &
(ddr)); ++(i))
    {
opt_result res
 = vect_analyze_data_ref_dependence (ddr, loop_vinfo, max_vf);
if (!res)
 return res;
    }

return opt_result::success ();
618}


621/* Function vect_slp_analyze_data_ref_dependence.

 Return TRUE if there (might) exist a dependence between a memory-reference
 DRA and a memory-reference DRB for VINFO.  When versioning for alias
 may check a dependence at run-time, return FALSE.  Adjust *MAX_VF
 according to the data dependence.  */

628static bool
629vect_slp_analyze_data_ref_dependence (vec_info *vinfo,
		      struct data_dependence_relation *ddr)
631{
struct data_reference *dra = DDR_A (ddr)(ddr)->a;
struct data_reference *drb = DDR_B (ddr)(ddr)->b;
dr_vec_info *dr_info_a = vinfo->lookup_dr (dra);
dr_vec_info *dr_info_b = vinfo->lookup_dr (drb);

/* We need to check dependences of statements marked as unvectorizable
   as well, they still can prohibit vectorization.  */

/* Independent data accesses.  */
if (DDR_ARE_DEPENDENT (ddr)(ddr)->are_dependent == chrec_knownglobal_trees[TI_CHREC_KNOWN])
  return false;

if (dra == drb)
  return false;

/* Read-read is OK.  */
if (DR_IS_READ (dra)(dra)->is_read && DR_IS_READ (drb)(drb)->is_read)
  return false;

/* If dra and drb are part of the same interleaving chain consider
   them independent.  */
if (STMT_VINFO_GROUPED_ACCESS (dr_info_a->stmt)((dr_info_a->stmt)->dr_aux.dr && (((void)(!((dr_info_a
->stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 653, __FUNCTION__), 0 : 0)), (dr_info_a->stmt)->first_element
))
    && (DR_GROUP_FIRST_ELEMENT (dr_info_a->stmt)(((void)(!((dr_info_a->stmt)->dr_aux.dr) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 654, __FUNCTION__), 0 : 0)), (dr_info_a->stmt)->first_element
)
 == DR_GROUP_FIRST_ELEMENT (dr_info_b->stmt)(((void)(!((dr_info_b->stmt)->dr_aux.dr) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 655, __FUNCTION__), 0 : 0)), (dr_info_b->stmt)->first_element
)))
  return false;

/* Unknown data dependence.  */
if (DDR_ARE_DEPENDENT (ddr)(ddr)->are_dependent == chrec_dont_knowglobal_trees[TI_CHREC_DONT_KNOW])
  {
    if  (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	 "can't determine dependence between %T and %T\n",
	 DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);
  }
else if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
     "determined dependence between %T and %T\n",
     DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);

return true;
672}


675/* Analyze dependences involved in the transform of SLP NODE.  STORES
 contain the vector of scalar stores of this instance if we are
 disambiguating the loads.  */

679static bool
680vect_slp_analyze_node_dependences (vec_info *vinfo, slp_tree node,
		   vec<stmt_vec_info> stores,
		   stmt_vec_info last_store_info)
683{
/* This walks over all stmts involved in the SLP load/store done
   in NODE verifying we can sink them up to the last stmt in the
   group.  */
if (DR_IS_WRITE (STMT_VINFO_DATA_REF (SLP_TREE_REPRESENTATIVE (node)))(!((((node)->representative)->dr_aux.dr + 0))->is_read
))
  {
    stmt_vec_info last_access_info = vect_find_last_scalar_stmt_in_slp (node);
    for (unsigned k = 0; k < SLP_TREE_SCALAR_STMTS (node)(node)->stmts.length (); ++k)
{
 stmt_vec_info access_info
   = vect_orig_stmt (SLP_TREE_SCALAR_STMTS (node)(node)->stmts[k]);
 if (access_info == last_access_info)
   continue;
 data_reference *dr_a = STMT_VINFO_DATA_REF (access_info)((access_info)->dr_aux.dr + 0);
 ao_ref ref;
 bool ref_initialized_p = false;
 for (gimple_stmt_iterator gsi = gsi_for_stmt (access_info->stmt);
      gsi_stmt (gsi) != last_access_info->stmt; gsi_next (&gsi))
   {
     gimple *stmt = gsi_stmt (gsi);
     if (! gimple_vuse (stmt))
continue;

     /* If we couldn't record a (single) data reference for this
 stmt we have to resort to the alias oracle.  */
     stmt_vec_info stmt_info = vinfo->lookup_stmt (stmt);
     data_reference *dr_b = STMT_VINFO_DATA_REF (stmt_info)((stmt_info)->dr_aux.dr + 0);
     if (!dr_b)
{
  /* We are moving a store - this means
     we cannot use TBAA for disambiguation.  */
  if (!ref_initialized_p)
    ao_ref_init (&ref, DR_REF (dr_a)(dr_a)->ref);
  if (stmt_may_clobber_ref_p_1 (stmt, &ref, false)
      || ref_maybe_used_by_stmt_p (stmt, &ref, false))
    return false;
  continue;
}

     bool dependent = false;
     /* If we run into a store of this same instance (we've just
 marked those) then delay dependence checking until we run
 into the last store because this is where it will have
 been sunk to (and we verify if we can do that as well).  */
     if (gimple_visited_p (stmt))
{
  if (stmt_info != last_store_info)
    continue;

  for (stmt_vec_info &store_info : stores)
    {
      data_reference *store_dr
	= STMT_VINFO_DATA_REF (store_info)((store_info)->dr_aux.dr + 0);
      ddr_p ddr = initialize_data_dependence_relation
		    (dr_a, store_dr, vNULL);
      dependent
	= vect_slp_analyze_data_ref_dependence (vinfo, ddr);
      free_dependence_relation (ddr);
      if (dependent)
	break;
    }
}
     else
{
  ddr_p ddr = initialize_data_dependence_relation (dr_a,
						   dr_b, vNULL);
  dependent = vect_slp_analyze_data_ref_dependence (vinfo, ddr);
  free_dependence_relation (ddr);
}
     if (dependent)
return false;
   }
}
  }
else /* DR_IS_READ */
  {
    stmt_vec_info first_access_info
= vect_find_first_scalar_stmt_in_slp (node);
    for (unsigned k = 0; k < SLP_TREE_SCALAR_STMTS (node)(node)->stmts.length (); ++k)
{
 stmt_vec_info access_info
   = vect_orig_stmt (SLP_TREE_SCALAR_STMTS (node)(node)->stmts[k]);
 if (access_info == first_access_info)
   continue;
 data_reference *dr_a = STMT_VINFO_DATA_REF (access_info)((access_info)->dr_aux.dr + 0);
 ao_ref ref;
 bool ref_initialized_p = false;
 for (gimple_stmt_iterator gsi = gsi_for_stmt (access_info->stmt);
      gsi_stmt (gsi) != first_access_info->stmt; gsi_prev (&gsi))
   {
     gimple *stmt = gsi_stmt (gsi);
     if (! gimple_vdef (stmt))
continue;

     /* If we couldn't record a (single) data reference for this
 stmt we have to resort to the alias oracle.  */
     stmt_vec_info stmt_info = vinfo->lookup_stmt (stmt);
     data_reference *dr_b = STMT_VINFO_DATA_REF (stmt_info)((stmt_info)->dr_aux.dr + 0);

     /* We are hoisting a load - this means we can use
 TBAA for disambiguation.  */
     if (!ref_initialized_p)
ao_ref_init (&ref, DR_REF (dr_a)(dr_a)->ref);
     if (stmt_may_clobber_ref_p_1 (stmt, &ref, true))
{
  if (!dr_b)
    return false;
  /* Resort to dependence checking below.  */
}
     else
/* No dependence.  */
continue;

     bool dependent = false;
     /* If we run into a store of this same instance (we've just
 marked those) then delay dependence checking until we run
 into the last store because this is where it will have
 been sunk to (and we verify if we can do that as well).  */
     if (gimple_visited_p (stmt))
{
  if (stmt_info != last_store_info)
    continue;

  for (stmt_vec_info &store_info : stores)
    {
      data_reference *store_dr
	= STMT_VINFO_DATA_REF (store_info)((store_info)->dr_aux.dr + 0);
      ddr_p ddr = initialize_data_dependence_relation
		    (dr_a, store_dr, vNULL);
      dependent
	= vect_slp_analyze_data_ref_dependence (vinfo, ddr);
      free_dependence_relation (ddr);
      if (dependent)
	break;
    }
}
     else
{
  ddr_p ddr = initialize_data_dependence_relation (dr_a,
						   dr_b, vNULL);
  dependent = vect_slp_analyze_data_ref_dependence (vinfo, ddr);
  free_dependence_relation (ddr);
}
     if (dependent)
return false;
   }
}
  }
return true;
832}


835/* Function vect_analyze_data_ref_dependences.

 Examine all the data references in the basic-block, and make sure there
 do not exist any data dependences between them.  Set *MAX_VF according to
 the maximum vectorization factor the data dependences allow.  */

841bool
842vect_slp_analyze_instance_dependence (vec_info *vinfo, slp_instance instance)
843{
DUMP_VECT_SCOPE ("vect_slp_analyze_instance_dependence")auto_dump_scope scope ("vect_slp_analyze_instance_dependence"
, vect_location);

/* The stores of this instance are at the root of the SLP tree.  */
slp_tree store = NULLnullptr;
if (SLP_INSTANCE_KIND (instance)(instance)->kind == slp_inst_kind_store)
  store = SLP_INSTANCE_TREE (instance)(instance)->root;

/* Verify we can sink stores to the vectorized stmt insert location.  */
stmt_vec_info last_store_info = NULLnullptr;
if (store)
  {
    if (! vect_slp_analyze_node_dependences (vinfo, store, vNULL, NULLnullptr))
return false;

    /* Mark stores in this instance and remember the last one.  */
    last_store_info = vect_find_last_scalar_stmt_in_slp (store);
    for (unsigned k = 0; k < SLP_TREE_SCALAR_STMTS (store)(store)->stmts.length (); ++k)
gimple_set_visited (SLP_TREE_SCALAR_STMTS (store)(store)->stmts[k]->stmt, true);
  }

bool res = true;

/* Verify we can sink loads to the vectorized stmt insert location,
   special-casing stores of this instance.  */
for (slp_tree &load : SLP_INSTANCE_LOADS (instance)(instance)->loads)
  if (! vect_slp_analyze_node_dependences (vinfo, load,
			     store
			     ? SLP_TREE_SCALAR_STMTS (store)(store)->stmts
			     : vNULL, last_store_info))
    {
res = false;
break;
    }

/* Unset the visited flag.  */
if (store)
  for (unsigned k = 0; k < SLP_TREE_SCALAR_STMTS (store)(store)->stmts.length (); ++k)
    gimple_set_visited (SLP_TREE_SCALAR_STMTS (store)(store)->stmts[k]->stmt, false);

return res;
884}

886/* Return the misalignment of DR_INFO accessed in VECTYPE with OFFSET
 applied.  */

889int
890dr_misalignment (dr_vec_info *dr_info, tree vectype, poly_int64 offset)
891{
HOST_WIDE_INTlong diff = 0;
/* Alignment is only analyzed for the first element of a DR group,
   use that but adjust misalignment by the offset of the access.  */
if (STMT_VINFO_GROUPED_ACCESS (dr_info->stmt)((dr_info->stmt)->dr_aux.dr && (((void)(!((dr_info
->stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 895, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
)))
  {
    dr_vec_info *first_dr
= STMT_VINFO_DR_INFO (DR_GROUP_FIRST_ELEMENT (dr_info->stmt))(((void)(!(((((void)(!((dr_info->stmt)->dr_aux.dr) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 898, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
))->dr_aux.stmt == ((((void)(!((dr_info->stmt)->dr_aux
.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 898, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
))) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 898, __FUNCTION__), 0 : 0)), &((((void)(!((dr_info->
stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 898, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
))->dr_aux);
    /* vect_analyze_data_ref_accesses guarantees that DR_INIT are
INTEGER_CSTs and the first element in the group has the lowest
address.  */
    diff = (TREE_INT_CST_LOW (DR_INIT (dr_info->dr))((unsigned long) (*tree_int_cst_elt_check (((dr_info->dr)->
innermost.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 902, __FUNCTION__)))
     - TREE_INT_CST_LOW (DR_INIT (first_dr->dr))((unsigned long) (*tree_int_cst_elt_check (((first_dr->dr)
->innermost.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 903, __FUNCTION__))));
    gcc_assert (diff >= 0)((void)(!(diff >= 0) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 904, __FUNCTION__), 0 : 0));
    dr_info = first_dr;
  }

int misalign = dr_info->misalignment;
gcc_assert (misalign != DR_MISALIGNMENT_UNINITIALIZED)((void)(!(misalign != (-2)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 909, __FUNCTION__), 0 : 0));
if (misalign == DR_MISALIGNMENT_UNKNOWN(-1))
  return misalign;

/* If the access is only aligned for a vector type with smaller alignment
   requirement the access has unknown misalignment.  */
if (maybe_lt (dr_info->target_alignment * BITS_PER_UNIT(8),
targetm.vectorize.preferred_vector_alignment (vectype)))
  return DR_MISALIGNMENT_UNKNOWN(-1);

/* Apply the offset from the DR group start and the externally supplied
   offset which can for example result from a negative stride access.  */
poly_int64 misalignment = misalign + diff + offset;

/* vect_compute_data_ref_alignment will have ensured that target_alignment
   is constant and otherwise set misalign to DR_MISALIGNMENT_UNKNOWN.  */
unsigned HOST_WIDE_INTlong target_alignment_c
  = dr_info->target_alignment.to_constant ();
if (!known_misalignment (misalignment, target_alignment_c, &misalign))
  return DR_MISALIGNMENT_UNKNOWN(-1);
return misalign;
930}

932/* Record the base alignment guarantee given by DRB, which occurs
 in STMT_INFO.  */

935static void
936vect_record_base_alignment (vec_info *vinfo, stmt_vec_info stmt_info,
	    innermost_loop_behavior *drb)
938{
bool existed;
std::pair<stmt_vec_info, innermost_loop_behavior *> &entry
  = vinfo->base_alignments.get_or_insert (drb->base_address, &existed);
if (!existed || entry.second->base_alignment < drb->base_alignment)
  {
    entry = std::make_pair (stmt_info, drb);
    if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
	 "recording new base alignment for %T\n"
	 "  alignment:    %d\n"
	 "  misalignment: %d\n"
	 "  based on:     %G",
	 drb->base_address,
	 drb->base_alignment,
	 drb->base_misalignment,
	 stmt_info->stmt);
  }
956}

958/* If the region we're going to vectorize is reached, all unconditional
 data references occur at least once.  We can therefore pool the base
 alignment guarantees from each unconditional reference.  Do this by
 going through all the data references in VINFO and checking whether
 the containing statement makes the reference unconditionally.  If so,
 record the alignment of the base address in VINFO so that it can be
 used for all other references with the same base.  */

966void
967vect_record_base_alignments (vec_info *vinfo)
968{
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
class loop *loop = loop_vinfo ? LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop : NULLnullptr;
for (data_reference *dr : vinfo->shared->datarefs)
  {
    dr_vec_info *dr_info = vinfo->lookup_dr (dr);
    stmt_vec_info stmt_info = dr_info->stmt;
    if (!DR_IS_CONDITIONAL_IN_STMT (dr)(dr)->is_conditional_in_stmt
 && STMT_VINFO_VECTORIZABLE (stmt_info)(stmt_info)->vectorizable
 && !STMT_VINFO_GATHER_SCATTER_P (stmt_info)(stmt_info)->gather_scatter_p)
{
 vect_record_base_alignment (vinfo, stmt_info, &DR_INNERMOST (dr)(dr)->innermost);

 /* If DR is nested in the loop that is being vectorized, we can also
    record the alignment of the base wrt the outer loop.  */
 if (loop && nested_in_vect_loop_p (loop, stmt_info))
   vect_record_base_alignment
     (vinfo, stmt_info, &STMT_VINFO_DR_WRT_VEC_LOOP (stmt_info)(stmt_info)->dr_wrt_vec_loop);
}
  }
988}

990/* Function vect_compute_data_ref_alignment

 Compute the misalignment of the data reference DR_INFO when vectorizing
 with VECTYPE.

 Output:
 1. initialized misalignment info for DR_INFO

 FOR NOW: No analysis is actually performed. Misalignment is calculated
 only for trivial cases. TODO.  */

1001static void
1002vect_compute_data_ref_alignment (vec_info *vinfo, dr_vec_info *dr_info,
		 tree vectype)
1004{
stmt_vec_info stmt_info = dr_info->stmt;
vec_base_alignments *base_alignments = &vinfo->base_alignments;
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
class loop *loop = NULLnullptr;
tree ref = DR_REF (dr_info->dr)(dr_info->dr)->ref;

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                   "vect_compute_data_ref_alignment:\n");

if (loop_vinfo)
  loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;

/* Initialize misalignment to unknown.  */
SET_DR_MISALIGNMENT (dr_info, DR_MISALIGNMENT_UNKNOWN)set_dr_misalignment (dr_info, (-1));

if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)(stmt_info)->gather_scatter_p)
  return;

innermost_loop_behavior *drb = vect_dr_behavior (vinfo, dr_info);
bool step_preserves_misalignment_p;

poly_uint64 vector_alignment
  = exact_div (targetm.vectorize.preferred_vector_alignment (vectype),
 BITS_PER_UNIT(8));
SET_DR_TARGET_ALIGNMENT (dr_info, vector_alignment)set_dr_target_alignment (dr_info, vector_alignment);

/* If the main loop has peeled for alignment we have no way of knowing
   whether the data accesses in the epilogues are aligned.  We can't at
   compile time answer the question whether we have entered the main loop or
   not.  Fixes PR 92351.  */
if (loop_vinfo)
  {
    loop_vec_info orig_loop_vinfo = LOOP_VINFO_ORIG_LOOP_INFO (loop_vinfo)(loop_vinfo)->orig_loop_info;
    if (orig_loop_vinfo
 && LOOP_VINFO_PEELING_FOR_ALIGNMENT (orig_loop_vinfo)(orig_loop_vinfo)->peeling_for_alignment != 0)
return;
  }

unsigned HOST_WIDE_INTlong vect_align_c;
if (!vector_alignment.is_constant (&vect_align_c))
  return;

/* No step for BB vectorization.  */
if (!loop)
  {
    gcc_assert (integer_zerop (drb->step))((void)(!(integer_zerop (drb->step)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1051, __FUNCTION__), 0 : 0));
    step_preserves_misalignment_p = true;
  }

/* In case the dataref is in an inner-loop of the loop that is being
   vectorized (LOOP), we use the base and misalignment information
   relative to the outer-loop (LOOP).  This is ok only if the misalignment
   stays the same throughout the execution of the inner-loop, which is why
   we have to check that the stride of the dataref in the inner-loop evenly
   divides by the vector alignment.  */
else if (nested_in_vect_loop_p (loop, stmt_info))
  {
    step_preserves_misalignment_p
= (DR_STEP_ALIGNMENT (dr_info->dr)(dr_info->dr)->innermost.step_alignment % vect_align_c) == 0;

    if (dump_enabled_p ())
{
 if (step_preserves_misalignment_p)
   dump_printf_loc (MSG_NOTE, vect_location,
	     "inner step divides the vector alignment.\n");
 else
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	     "inner step doesn't divide the vector"
	     " alignment.\n");
}
  }

/* Similarly we can only use base and misalignment information relative to
   an innermost loop if the misalignment stays the same throughout the
   execution of the loop.  As above, this is the case if the stride of
   the dataref evenly divides by the alignment.  */
else
  {
    poly_uint64 vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo)(loop_vinfo)->vectorization_factor;
    step_preserves_misalignment_p
= multiple_p (DR_STEP_ALIGNMENT (dr_info->dr)(dr_info->dr)->innermost.step_alignment * vf, vect_align_c);

    if (!step_preserves_misalignment_p && dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	 "step doesn't divide the vector alignment.\n");
  }

unsigned int base_alignment = drb->base_alignment;
unsigned int base_misalignment = drb->base_misalignment;

/* Calculate the maximum of the pooled base address alignment and the
   alignment that we can compute for DR itself.  */
std::pair<stmt_vec_info, innermost_loop_behavior *> *entry
  = base_alignments->get (drb->base_address);
if (entry
    && base_alignment < (*entry).second->base_alignment
    && (loop_vinfo
 || (dominated_by_p (CDI_DOMINATORS, gimple_bb (stmt_info->stmt),
	      gimple_bb (entry->first->stmt))
     && (gimple_bb (stmt_info->stmt) != gimple_bb (entry->first->stmt)
  || (entry->first->dr_aux.group <= dr_info->group)))))
  {
    base_alignment = entry->second->base_alignment;
    base_misalignment = entry->second->base_misalignment;
  }

if (drb->offset_alignment < vect_align_c
    || !step_preserves_misalignment_p
    /* We need to know whether the step wrt the vectorized loop is
negative when computing the starting misalignment below.  */
    || TREE_CODE (drb->step)((enum tree_code) (drb->step)->base.code) != INTEGER_CST)
  {
    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	 "Unknown alignment for access: %T\n", ref);
    return;
  }

if (base_alignment < vect_align_c)
  {
    unsigned int max_alignment;
    tree base = get_base_for_alignment (drb->base_address, &max_alignment);
    if (max_alignment < vect_align_c
 || !vect_can_force_dr_alignment_p (base,
			     vect_align_c * BITS_PER_UNIT(8)))
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "can't force alignment of ref: %T\n", ref);
 return;
}

    /* Force the alignment of the decl.
NOTE: This is the only change to the code we make during
the analysis phase, before deciding to vectorize the loop.  */
    if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
	 "force alignment of %T\n", ref);

    dr_info->base_decl = base;
    dr_info->base_misaligned = true;
    base_misalignment = 0;
  }
poly_int64 misalignment
  = base_misalignment + wi::to_poly_offset (drb->init).force_shwi ();

unsigned int const_misalignment;
if (!known_misalignment (misalignment, vect_align_c, &const_misalignment))
  {
    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	 "Non-constant misalignment for access: %T\n", ref);
    return;
  }

SET_DR_MISALIGNMENT (dr_info, const_misalignment)set_dr_misalignment (dr_info, const_misalignment);

if (dump_enabled_p ())
  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
     "misalign = %d bytes of ref %T\n",
     const_misalignment, ref);

return;
1169}

1171/* Return whether DR_INFO, which is related to DR_PEEL_INFO in
 that it only differs in DR_INIT, is aligned if DR_PEEL_INFO
 is made aligned via peeling.  */

1175static bool
1176vect_dr_aligned_if_related_peeled_dr_is (dr_vec_info *dr_info,
			 dr_vec_info *dr_peel_info)
1178{
if (multiple_p (DR_TARGET_ALIGNMENT (dr_peel_info)dr_target_alignment (dr_peel_info),
  DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info)))
  {
    poly_offset_int diff
= (wi::to_poly_offset (DR_INIT (dr_peel_info->dr)(dr_peel_info->dr)->innermost.init)
  - wi::to_poly_offset (DR_INIT (dr_info->dr)(dr_info->dr)->innermost.init));
    if (known_eq (diff, 0)(!maybe_ne (diff, 0))
 || multiple_p (diff, DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info)))
return true;
  }
return false;
1190}

1192/* Return whether DR_INFO is aligned if DR_PEEL_INFO is made
 aligned via peeling.  */

1195static bool
1196vect_dr_aligned_if_peeled_dr_is (dr_vec_info *dr_info,
		 dr_vec_info *dr_peel_info)
1198{
if (!operand_equal_p (DR_BASE_ADDRESS (dr_info->dr)(dr_info->dr)->innermost.base_address,
	DR_BASE_ADDRESS (dr_peel_info->dr)(dr_peel_info->dr)->innermost.base_address, 0)
    || !operand_equal_p (DR_OFFSET (dr_info->dr)(dr_info->dr)->innermost.offset,
	   DR_OFFSET (dr_peel_info->dr)(dr_peel_info->dr)->innermost.offset, 0)
    || !operand_equal_p (DR_STEP (dr_info->dr)(dr_info->dr)->innermost.step,
	   DR_STEP (dr_peel_info->dr)(dr_peel_info->dr)->innermost.step, 0))
  return false;

return vect_dr_aligned_if_related_peeled_dr_is (dr_info, dr_peel_info);
1208}

1210/* Compute the value for dr_info->misalign so that the access appears
 aligned.  This is used by peeling to compensate for dr_misalignment
 applying the offset for negative step.  */

1214int
1215vect_dr_misalign_for_aligned_access (dr_vec_info *dr_info)
1216{
if (tree_int_cst_sgn (DR_STEP (dr_info->dr)(dr_info->dr)->innermost.step) >= 0)
  return 0;

tree vectype = STMT_VINFO_VECTYPE (dr_info->stmt)(dr_info->stmt)->vectype;
poly_int64 misalignment
  = ((TYPE_VECTOR_SUBPARTS (vectype) - 1)
     * TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1223, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1223, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1223, __FUNCTION__))));

unsigned HOST_WIDE_INTlong target_alignment_c;
int misalign;
if (!dr_info->target_alignment.is_constant (&target_alignment_c)
    || !known_misalignment (misalignment, target_alignment_c, &misalign))
  return DR_MISALIGNMENT_UNKNOWN(-1);
return misalign;
1231}

1233/* Function vect_update_misalignment_for_peel.
 Sets DR_INFO's misalignment
 - to 0 if it has the same alignment as DR_PEEL_INFO,
 - to the misalignment computed using NPEEL if DR_INFO's salignment is known,
 - to -1 (unknown) otherwise.

 DR_INFO - the data reference whose misalignment is to be adjusted.
 DR_PEEL_INFO - the data reference whose misalignment is being made
  zero in the vector loop by the peel.
 NPEEL - the number of iterations in the peel loop if the misalignment
         of DR_PEEL_INFO is known at compile time.  */

1245static void
1246vect_update_misalignment_for_peel (dr_vec_info *dr_info,
		   dr_vec_info *dr_peel_info, int npeel)
1248{
/* If dr_info is aligned of dr_peel_info is, then mark it so.  */
if (vect_dr_aligned_if_peeled_dr_is (dr_info, dr_peel_info))
  {
    SET_DR_MISALIGNMENT (dr_info,set_dr_misalignment (dr_info, vect_dr_misalign_for_aligned_access
 (dr_peel_info))
	   vect_dr_misalign_for_aligned_access (dr_peel_info))set_dr_misalignment (dr_info, vect_dr_misalign_for_aligned_access
 (dr_peel_info));
    return;
  }

unsigned HOST_WIDE_INTlong alignment;
if (DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info).is_constant (&alignment)
    && known_alignment_for_access_p (dr_info,
		       STMT_VINFO_VECTYPE (dr_info->stmt)(dr_info->stmt)->vectype)
    && known_alignment_for_access_p (dr_peel_info,
		       STMT_VINFO_VECTYPE (dr_peel_info->stmt)(dr_peel_info->stmt)->vectype))
  {
    int misal = dr_info->misalignment;
    misal += npeel * TREE_INT_CST_LOW (DR_STEP (dr_info->dr))((unsigned long) (*tree_int_cst_elt_check (((dr_info->dr)->
innermost.step), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1265, __FUNCTION__)));
    misal &= alignment - 1;
    set_dr_misalignment (dr_info, misal);
    return;
  }

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location, "Setting misalignment " \
     "to unknown (-1).\n");
SET_DR_MISALIGNMENT (dr_info, DR_MISALIGNMENT_UNKNOWN)set_dr_misalignment (dr_info, (-1));
1275}

1277/* Return true if alignment is relevant for DR_INFO.  */

1279static bool
1280vect_relevant_for_alignment_p (dr_vec_info *dr_info)
1281{
stmt_vec_info stmt_info = dr_info->stmt;

if (!STMT_VINFO_RELEVANT_P (stmt_info)((stmt_info)->relevant != vect_unused_in_scope))
  return false;

/* For interleaving, only the alignment of the first access matters.  */
if (STMT_VINFO_GROUPED_ACCESS (stmt_info)((stmt_info)->dr_aux.dr && (((void)(!((stmt_info)->
dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1288, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))
    && DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1289, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) != stmt_info)
  return false;

/* Scatter-gather and invariant accesses continue to address individual
   scalars, so vector-level alignment is irrelevant.  */
if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)(stmt_info)->gather_scatter_p
    || integer_zerop (DR_STEP (dr_info->dr)(dr_info->dr)->innermost.step))
  return false;

/* Strided accesses perform only component accesses, alignment is
   irrelevant for them.  */
if (STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p
    && !STMT_VINFO_GROUPED_ACCESS (stmt_info)((stmt_info)->dr_aux.dr && (((void)(!((stmt_info)->
dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1301, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
)))
  return false;

return true;
1305}

1307/* Given an memory reference EXP return whether its alignment is less
 than its size.  */

1310static bool
1311not_size_aligned (tree exp)
1312{
if (!tree_fits_uhwi_p (TYPE_SIZE (TREE_TYPE (exp))((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1313, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1313, __FUNCTION__))->type_common.size)))
  return true;

return (tree_to_uhwi (TYPE_SIZE (TREE_TYPE (exp))((tree_class_check ((((contains_struct_check ((exp), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1316, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1316, __FUNCTION__))->type_common.size))
 > get_object_alignment (exp));
1318}

1320/* Function vector_alignment_reachable_p

 Return true if vector alignment for DR_INFO is reachable by peeling
 a few loop iterations.  Return false otherwise.  */

1325static bool
1326vector_alignment_reachable_p (dr_vec_info *dr_info)
1327{
stmt_vec_info stmt_info = dr_info->stmt;
tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;

if (STMT_VINFO_GROUPED_ACCESS (stmt_info)((stmt_info)->dr_aux.dr && (((void)(!((stmt_info)->
dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1331, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
)))
  {
    /* For interleaved access we peel only if number of iterations in
the prolog loop ({VF - misalignment}), is a multiple of the
number of the interleaved accesses.  */
    int elem_size, mis_in_elements;

    /* FORNOW: handle only known alignment.  */
    if (!known_alignment_for_access_p (dr_info, vectype))
return false;

    poly_uint64 nelements = TYPE_VECTOR_SUBPARTS (vectype);
    poly_uint64 vector_size = GET_MODE_SIZE (TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1343, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (vectype) : (vectype)->type_common.mode));
    elem_size = vector_element_size (vector_size, nelements)(exact_div (vector_size, nelements).to_constant ());
    mis_in_elements = dr_misalignment (dr_info, vectype) / elem_size;

    if (!multiple_p (nelements - mis_in_elements, DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1347, __FUNCTION__), 0 : 0)), (stmt_info)->size)))
return false;
  }

/* If misalignment is known at the compile time then allow peeling
   only if natural alignment is reachable through peeling.  */
if (known_alignment_for_access_p (dr_info, vectype)
    && !aligned_access_p (dr_info, vectype))
  {
    HOST_WIDE_INTlong elmsize =
int_cst_value (TYPE_SIZE_UNIT (TREE_TYPE (vectype))((tree_class_check ((((contains_struct_check ((vectype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1357, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1357, __FUNCTION__))->type_common.size_unit));
    if (dump_enabled_p ())
{
 dump_printf_loc (MSG_NOTE, vect_location,
                  "data size = %wd. misalignment = %d.\n", elmsize,
	   dr_misalignment (dr_info, vectype));
}
    if (dr_misalignment (dr_info, vectype) % elmsize)
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                    "data size does not divide the misalignment.\n");
 return false;
}
  }

if (!known_alignment_for_access_p (dr_info, vectype))
  {
    tree type = TREE_TYPE (DR_REF (dr_info->dr))((contains_struct_check (((dr_info->dr)->ref), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1375, __FUNCTION__))->typed.type);
    bool is_packed = not_size_aligned (DR_REF (dr_info->dr)(dr_info->dr)->ref);
    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                "Unknown misalignment, %snaturally aligned\n",
	 is_packed ? "not " : "");
    return targetm.vectorize.vector_alignment_reachable (type, is_packed);
  }

return true;
1385}


1388/* Calculate the cost of the memory access represented by DR_INFO.  */

1390static void
1391vect_get_data_access_cost (vec_info *vinfo, dr_vec_info *dr_info,
	   dr_alignment_support alignment_support_scheme,
	   int misalignment,
	   unsigned int *inside_cost,
                         unsigned int *outside_cost,
	   stmt_vector_for_cost *body_cost_vec,
	   stmt_vector_for_cost *prologue_cost_vec)
1398{
stmt_vec_info stmt_info = dr_info->stmt;
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
int ncopies;

if (PURE_SLP_STMT (stmt_info)((stmt_info)->slp_type == pure_slp))
  ncopies = 1;
else
  ncopies = vect_get_num_copies (loop_vinfo, STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype);

if (DR_IS_READ (dr_info->dr)(dr_info->dr)->is_read)
  vect_get_load_cost (vinfo, stmt_info, ncopies, alignment_support_scheme,
	misalignment, true, inside_cost,
	outside_cost, prologue_cost_vec, body_cost_vec, false);
else
  vect_get_store_cost (vinfo,stmt_info, ncopies, alignment_support_scheme,
	 misalignment, inside_cost, body_cost_vec);

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
                   "vect_get_data_access_cost: inside_cost = %d, "
                   "outside_cost = %d.\n", *inside_cost, *outside_cost);
1420}


1423typedef struct _vect_peel_info
1424{
dr_vec_info *dr_info;
int npeel;
unsigned int count;
1428} *vect_peel_info;

1430typedef struct _vect_peel_extended_info
1431{
vec_info *vinfo;
struct _vect_peel_info peel_info;
unsigned int inside_cost;
unsigned int outside_cost;
1436} *vect_peel_extended_info;


1439/* Peeling hashtable helpers.  */

1441struct peel_info_hasher : free_ptr_hash <_vect_peel_info>
1442{
static inline hashval_t hash (const _vect_peel_info *);
static inline bool equal (const _vect_peel_info *, const _vect_peel_info *);
1445};

1447inline hashval_t
1448peel_info_hasher::hash (const _vect_peel_info *peel_info)
1449{
return (hashval_t) peel_info->npeel;
1451}

1453inline bool
1454peel_info_hasher::equal (const _vect_peel_info *a, const _vect_peel_info *b)
1455{
return (a->npeel == b->npeel);
1457}


1460/* Insert DR_INFO into peeling hash table with NPEEL as key.  */

1462static void
1463vect_peeling_hash_insert (hash_table<peel_info_hasher> *peeling_htab,
	  loop_vec_info loop_vinfo, dr_vec_info *dr_info,
	  int npeel, bool supportable_if_not_aligned)
1466{
struct _vect_peel_info elem, *slot;
_vect_peel_info **new_slot;

elem.npeel = npeel;
slot = peeling_htab->find (&elem);
if (slot)
  slot->count++;
else
  {
    slot = XNEW (struct _vect_peel_info)((struct _vect_peel_info *) xmalloc (sizeof (struct _vect_peel_info
)));
    slot->npeel = npeel;
    slot->dr_info = dr_info;
    slot->count = 1;
    new_slot = peeling_htab->find_slot (slot, INSERT);
    *new_slot = slot;
  }

/* If this DR is not supported with unknown misalignment then bias
   this slot when the cost model is disabled.  */
if (!supportable_if_not_aligned
    && unlimited_cost_model (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop))
  slot->count += VECT_MAX_COST1000;
1489}


1492/* Traverse peeling hash table to find peeling option that aligns maximum
 number of data accesses.  */

1495int
1496vect_peeling_hash_get_most_frequent (_vect_peel_info **slot,
		     _vect_peel_extended_info *max)
1498{
vect_peel_info elem = *slot;

if (elem->count > max->peel_info.count
    || (elem->count == max->peel_info.count
        && max->peel_info.npeel > elem->npeel))
  {
    max->peel_info.npeel = elem->npeel;
    max->peel_info.count = elem->count;
    max->peel_info.dr_info = elem->dr_info;
  }

return 1;
1511}

1513/* Get the costs of peeling NPEEL iterations for LOOP_VINFO, checking
 data access costs for all data refs.  If UNKNOWN_MISALIGNMENT is true,
 npeel is computed at runtime but DR0_INFO's misalignment will be zero
 after peeling.  */

1518static void
1519vect_get_peeling_costs_all_drs (loop_vec_info loop_vinfo,
		dr_vec_info *dr0_info,
		unsigned int *inside_cost,
		unsigned int *outside_cost,
		stmt_vector_for_cost *body_cost_vec,
		stmt_vector_for_cost *prologue_cost_vec,
		unsigned int npeel)
1526{
vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs;

bool dr0_alignment_known_p
  = (dr0_info
     && known_alignment_for_access_p (dr0_info,
			STMT_VINFO_VECTYPE (dr0_info->stmt)(dr0_info->stmt)->vectype));

for (data_reference *dr : datarefs)
  {
    dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
    if (!vect_relevant_for_alignment_p (dr_info))
continue;

    tree vectype = STMT_VINFO_VECTYPE (dr_info->stmt)(dr_info->stmt)->vectype;
    dr_alignment_support alignment_support_scheme;
    int misalignment;
    unsigned HOST_WIDE_INTlong alignment;

    bool negative = tree_int_cst_compare (DR_STEP (dr_info->dr)(dr_info->dr)->innermost.step,
			    size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0;
    poly_int64 off = 0;
    if (negative)
off = ((TYPE_VECTOR_SUBPARTS (vectype) - 1)
      * -TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1550, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1550, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1550, __FUNCTION__))));

    if (npeel == 0)
misalignment = dr_misalignment (dr_info, vectype, off);
    else if (dr_info == dr0_info
      || vect_dr_aligned_if_peeled_dr_is (dr_info, dr0_info))
misalignment = 0;
    else if (!dr0_alignment_known_p
      || !known_alignment_for_access_p (dr_info, vectype)
      || !DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info).is_constant (&alignment))
misalignment = DR_MISALIGNMENT_UNKNOWN(-1);
    else
{
 misalignment = dr_misalignment (dr_info, vectype, off);
 misalignment += npeel * TREE_INT_CST_LOW (DR_STEP (dr_info->dr))((unsigned long) (*tree_int_cst_elt_check (((dr_info->dr)->
innermost.step), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1564, __FUNCTION__)));
 misalignment &= alignment - 1;
}
    alignment_support_scheme
= vect_supportable_dr_alignment (loop_vinfo, dr_info, vectype,
			 misalignment);

    vect_get_data_access_cost (loop_vinfo, dr_info,
		 alignment_support_scheme, misalignment,
		 inside_cost, outside_cost,
		 body_cost_vec, prologue_cost_vec);
  }
1576}

1578/* Traverse peeling hash table and calculate cost for each peeling option.
 Find the one with the lowest cost.  */

1581int
1582vect_peeling_hash_get_lowest_cost (_vect_peel_info **slot,
		   _vect_peel_extended_info *min)
1584{
vect_peel_info elem = *slot;
int dummy;
unsigned int inside_cost = 0, outside_cost = 0;
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (min->vinfo);
stmt_vector_for_cost prologue_cost_vec, body_cost_vec,
       epilogue_cost_vec;

prologue_cost_vec.create (2);
body_cost_vec.create (2);
epilogue_cost_vec.create (2);

vect_get_peeling_costs_all_drs (loop_vinfo, elem->dr_info, &inside_cost,
		  &outside_cost, &body_cost_vec,
		  &prologue_cost_vec, elem->npeel);

body_cost_vec.release ();

outside_cost += vect_get_known_peeling_cost
  (loop_vinfo, elem->npeel, &dummy,
   &LOOP_VINFO_SCALAR_ITERATION_COST (loop_vinfo)(loop_vinfo)->scalar_cost_vec,
   &prologue_cost_vec, &epilogue_cost_vec);

/* Prologue and epilogue costs are added to the target model later.
   These costs depend only on the scalar iteration cost, the
   number of peeling iterations finally chosen, and the number of
   misaligned statements.  So discard the information found here.  */
prologue_cost_vec.release ();
epilogue_cost_vec.release ();

if (inside_cost < min->inside_cost
    || (inside_cost == min->inside_cost
 && outside_cost < min->outside_cost))
  {
    min->inside_cost = inside_cost;
    min->outside_cost = outside_cost;
    min->peel_info.dr_info = elem->dr_info;
    min->peel_info.npeel = elem->npeel;
    min->peel_info.count = elem->count;
  }

return 1;
1626}


1629/* Choose best peeling option by traversing peeling hash table and either
 choosing an option with the lowest cost (if cost model is enabled) or the
 option that aligns as many accesses as possible.  */

1633static struct _vect_peel_extended_info
1634vect_peeling_hash_choose_best_peeling (hash_table<peel_info_hasher> *peeling_htab,
		       loop_vec_info loop_vinfo)
1636{
 struct _vect_peel_extended_info res;

 res.peel_info.dr_info = NULLnullptr;
 res.vinfo = loop_vinfo;

 if (!unlimited_cost_model (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop))
   {
     res.inside_cost = INT_MAX2147483647;
     res.outside_cost = INT_MAX2147483647;
     peeling_htab->traverse <_vect_peel_extended_info *,
  		       vect_peeling_hash_get_lowest_cost> (&res);
   }
 else
   {
     res.peel_info.count = 0;
     peeling_htab->traverse <_vect_peel_extended_info *,
  		       vect_peeling_hash_get_most_frequent> (&res);
     res.inside_cost = 0;
     res.outside_cost = 0;
   }

 return res;
1659}

1661/* Return true if the new peeling NPEEL is supported.  */

1663static bool
1664vect_peeling_supportable (loop_vec_info loop_vinfo, dr_vec_info *dr0_info,
	  unsigned npeel)
1666{
vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs;
enum dr_alignment_support supportable_dr_alignment;

bool dr0_alignment_known_p
  = known_alignment_for_access_p (dr0_info,
		    STMT_VINFO_VECTYPE (dr0_info->stmt)(dr0_info->stmt)->vectype);

/* Ensure that all data refs can be vectorized after the peel.  */
for (data_reference *dr : datarefs)
  {
    if (dr == dr0_info->dr)
continue;

    dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
    if (!vect_relevant_for_alignment_p (dr_info)
 || vect_dr_aligned_if_peeled_dr_is (dr_info, dr0_info))
continue;

    tree vectype = STMT_VINFO_VECTYPE (dr_info->stmt)(dr_info->stmt)->vectype;
    int misalignment;
    unsigned HOST_WIDE_INTlong alignment;
    if (!dr0_alignment_known_p
 || !known_alignment_for_access_p (dr_info, vectype)
 || !DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info).is_constant (&alignment))
misalignment = DR_MISALIGNMENT_UNKNOWN(-1);
    else
{
 misalignment = dr_misalignment (dr_info, vectype);
 misalignment += npeel * TREE_INT_CST_LOW (DR_STEP (dr_info->dr))((unsigned long) (*tree_int_cst_elt_check (((dr_info->dr)->
innermost.step), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1695, __FUNCTION__)));
 misalignment &= alignment - 1;
}
    supportable_dr_alignment
= vect_supportable_dr_alignment (loop_vinfo, dr_info, vectype,
			 misalignment);
    if (supportable_dr_alignment == dr_unaligned_unsupported)
return false;
  }

return true;
1706}

1708/* Compare two data-references DRA and DRB to group them into chunks
 with related alignment.  */

1711static int
1712dr_align_group_sort_cmp (const void *dra_, const void *drb_)
1713{
data_reference_p dra = *(data_reference_p *)const_cast<void *>(dra_);
data_reference_p drb = *(data_reference_p *)const_cast<void *>(drb_);
int cmp;

/* Stabilize sort.  */
if (dra == drb)
  return 0;

/* Ordering of DRs according to base.  */
cmp = data_ref_compare_tree (DR_BASE_ADDRESS (dra)(dra)->innermost.base_address,
	       DR_BASE_ADDRESS (drb)(drb)->innermost.base_address);
if (cmp != 0)
  return cmp;

/* And according to DR_OFFSET.  */
cmp = data_ref_compare_tree (DR_OFFSET (dra)(dra)->innermost.offset, DR_OFFSET (drb)(drb)->innermost.offset);
if (cmp != 0)
  return cmp;

/* And after step.  */
cmp = data_ref_compare_tree (DR_STEP (dra)(dra)->innermost.step, DR_STEP (drb)(drb)->innermost.step);
if (cmp != 0)
  return cmp;

/* Then sort after DR_INIT.  In case of identical DRs sort after stmt UID.  */
cmp = data_ref_compare_tree (DR_INIT (dra)(dra)->innermost.init, DR_INIT (drb)(drb)->innermost.init);
if (cmp == 0)
  return gimple_uid (DR_STMT (dra)(dra)->stmt) < gimple_uid (DR_STMT (drb)(drb)->stmt) ? -1 : 1;
return cmp;
1743}

1745/* Function vect_enhance_data_refs_alignment

 This pass will use loop versioning and loop peeling in order to enhance
 the alignment of data references in the loop.

 FOR NOW: we assume that whatever versioning/peeling takes place, only the
 original loop is to be vectorized.  Any other loops that are created by
 the transformations performed in this pass - are not supposed to be
 vectorized.  This restriction will be relaxed.

 This pass will require a cost model to guide it whether to apply peeling
 or versioning or a combination of the two.  For example, the scheme that
 intel uses when given a loop with several memory accesses, is as follows:
 choose one memory access ('p') which alignment you want to force by doing
 peeling.  Then, either (1) generate a loop in which 'p' is aligned and all
 other accesses are not necessarily aligned, or (2) use loop versioning to
 generate one loop in which all accesses are aligned, and another loop in
 which only 'p' is necessarily aligned.

 ("Automatic Intra-Register Vectorization for the Intel Architecture",
 Aart J.C. Bik, Milind Girkar, Paul M. Grey and Ximmin Tian, International
 Journal of Parallel Programming, Vol. 30, No. 2, April 2002.)

 Devising a cost model is the most critical aspect of this work.  It will
 guide us on which access to peel for, whether to use loop versioning, how
 many versions to create, etc.  The cost model will probably consist of
 generic considerations as well as target specific considerations (on
 powerpc for example, misaligned stores are more painful than misaligned
 loads).

 Here are the general steps involved in alignment enhancements:

   -- original loop, before alignment analysis:
for (i=0; i<N; i++){
 x = q[i];			# DR_MISALIGNMENT(q) = unknown
 p[i] = y;			# DR_MISALIGNMENT(p) = unknown
}

   -- After vect_compute_data_refs_alignment:
for (i=0; i<N; i++){
 x = q[i];			# DR_MISALIGNMENT(q) = 3
 p[i] = y;			# DR_MISALIGNMENT(p) = unknown
}

   -- Possibility 1: we do loop versioning:
   if (p is aligned) {
for (i=0; i<N; i++){	# loop 1A
 x = q[i];			# DR_MISALIGNMENT(q) = 3
 p[i] = y;			# DR_MISALIGNMENT(p) = 0
}
   }
   else {
for (i=0; i<N; i++){	# loop 1B
 x = q[i];			# DR_MISALIGNMENT(q) = 3
 p[i] = y;			# DR_MISALIGNMENT(p) = unaligned
}
   }

   -- Possibility 2: we do loop peeling:
   for (i = 0; i < 3; i++){	# (scalar loop, not to be vectorized).
x = q[i];
p[i] = y;
   }
   for (i = 3; i < N; i++){	# loop 2A
x = q[i];			# DR_MISALIGNMENT(q) = 0
p[i] = y;			# DR_MISALIGNMENT(p) = unknown
   }

   -- Possibility 3: combination of loop peeling and versioning:
   for (i = 0; i < 3; i++){	# (scalar loop, not to be vectorized).
x = q[i];
p[i] = y;
   }
   if (p is aligned) {
for (i = 3; i<N; i++){	# loop 3A
 x = q[i];			# DR_MISALIGNMENT(q) = 0
 p[i] = y;			# DR_MISALIGNMENT(p) = 0
}
   }
   else {
for (i = 3; i<N; i++){	# loop 3B
 x = q[i];			# DR_MISALIGNMENT(q) = 0
 p[i] = y;			# DR_MISALIGNMENT(p) = unaligned
}
   }

   These loops are later passed to loop_transform to be vectorized.  The
   vectorizer will use the alignment information to guide the transformation
   (whether to generate regular loads/stores, or with special handling for
   misalignment).  */

1836opt_result
1837vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo)
1838{
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;
dr_vec_info *first_store = NULLnullptr;
dr_vec_info *dr0_info = NULLnullptr;
struct data_reference *dr;
unsigned int i;
bool do_peeling = false;
bool do_versioning = false;
unsigned int npeel = 0;
bool one_misalignment_known = false;
bool one_misalignment_unknown = false;
bool one_dr_unsupportable = false;
dr_vec_info *unsupportable_dr_info = NULLnullptr;
unsigned int dr0_same_align_drs = 0, first_store_same_align_drs = 0;
hash_table<peel_info_hasher> peeling_htab (1);

DUMP_VECT_SCOPE ("vect_enhance_data_refs_alignment")auto_dump_scope scope ("vect_enhance_data_refs_alignment", vect_location
);

/* Reset data so we can safely be called multiple times.  */
LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)(loop_vinfo)->may_misalign_stmts.truncate (0);
LOOP_VINFO_PEELING_FOR_ALIGNMENT (loop_vinfo)(loop_vinfo)->peeling_for_alignment = 0;

if (LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs.is_empty ())
  return opt_result::success ();

/* Sort the vector of datarefs so DRs that have the same or dependent
   alignment are next to each other.  */
auto_vec<data_reference_p> datarefs
  = LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs.copy ();
datarefs.qsort (dr_align_group_sort_cmp)qsort (dr_align_group_sort_cmp);

/* Compute the number of DRs that become aligned when we peel
   a dataref so it becomes aligned.  */
auto_vec<unsigned> n_same_align_refs (datarefs.length ());
n_same_align_refs.quick_grow_cleared (datarefs.length ());
unsigned i0;
for (i0 = 0; i0 < datarefs.length (); ++i0)
  if (DR_BASE_ADDRESS (datarefs[i0])(datarefs[i0])->innermost.base_address)
    break;
for (i = i0 + 1; i <= datarefs.length (); ++i)
  {
    if (i == datarefs.length ()
 || !operand_equal_p (DR_BASE_ADDRESS (datarefs[i0])(datarefs[i0])->innermost.base_address,
	       DR_BASE_ADDRESS (datarefs[i])(datarefs[i])->innermost.base_address, 0)
 || !operand_equal_p (DR_OFFSET (datarefs[i0])(datarefs[i0])->innermost.offset,
	       DR_OFFSET (datarefs[i])(datarefs[i])->innermost.offset, 0)
 || !operand_equal_p (DR_STEP (datarefs[i0])(datarefs[i0])->innermost.step,
	       DR_STEP (datarefs[i])(datarefs[i])->innermost.step, 0))
{
 /* The subgroup [i0, i-1] now only differs in DR_INIT and
    possibly DR_TARGET_ALIGNMENT.  Still the whole subgroup
    will get known misalignment if we align one of the refs
    with the largest DR_TARGET_ALIGNMENT.  */
 for (unsigned j = i0; j < i; ++j)
   {
     dr_vec_info *dr_infoj = loop_vinfo->lookup_dr (datarefs[j]);
     for (unsigned k = i0; k < i; ++k)
{
  if (k == j)
    continue;
  dr_vec_info *dr_infok = loop_vinfo->lookup_dr (datarefs[k]);
  if (vect_dr_aligned_if_related_peeled_dr_is (dr_infok,
					       dr_infoj))
    n_same_align_refs[j]++;
}
   }
 i0 = i;
}
  }

/* While cost model enhancements are expected in the future, the high level
   view of the code at this time is as follows:

   A) If there is a misaligned access then see if peeling to align
      this access can make all data references satisfy
      vect_supportable_dr_alignment.  If so, update data structures
      as needed and return true.

   B) If peeling wasn't possible and there is a data reference with an
      unknown misalignment that does not satisfy vect_supportable_dr_alignment
      then see if loop versioning checks can be used to make all data
      references satisfy vect_supportable_dr_alignment.  If so, update
      data structures as needed and return true.

   C) If neither peeling nor versioning were successful then return false if
      any data reference does not satisfy vect_supportable_dr_alignment.

   D) Return true (all data references satisfy vect_supportable_dr_alignment).

   Note, Possibility 3 above (which is peeling and versioning together) is not
   being done at this time.  */

/* (1) Peeling to force alignment.  */

/* (1.1) Decide whether to perform peeling, and how many iterations to peel:
   Considerations:
   + How many accesses will become aligned due to the peeling
   - How many accesses will become unaligned due to the peeling,
     and the cost of misaligned accesses.
   - The cost of peeling (the extra runtime checks, the increase
     in code size).  */

FOR_EACH_VEC_ELT (datarefs, i, dr)for (i = 0; (datarefs).iterate ((i), &(dr)); ++(i))
  {
    dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
    if (!vect_relevant_for_alignment_p (dr_info))
continue;

    stmt_vec_info stmt_info = dr_info->stmt;
    tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;
    do_peeling = vector_alignment_reachable_p (dr_info);
    if (do_peeling)
      {
 if (known_alignment_for_access_p (dr_info, vectype))
          {
     unsigned int npeel_tmp = 0;
     bool negative = tree_int_cst_compare (DR_STEP (dr)(dr)->innermost.step,
				    size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0;

     /* If known_alignment_for_access_p then we have set
        DR_MISALIGNMENT which is only done if we know it at compiler
        time, so it is safe to assume target alignment is constant.
      */
     unsigned int target_align =
DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info).to_constant ();
     unsigned HOST_WIDE_INTlong dr_size = vect_get_scalar_dr_size (dr_info);
     poly_int64 off = 0;
     if (negative)
off = (TYPE_VECTOR_SUBPARTS (vectype) - 1) * -dr_size;
     unsigned int mis = dr_misalignment (dr_info, vectype, off);
     mis = negative ? mis : -mis;
     if (mis != 0)
npeel_tmp = (mis & (target_align - 1)) / dr_size;

            /* For multiple types, it is possible that the bigger type access
               will have more than one peeling option.  E.g., a loop with two
               types: one of size (vector size / 4), and the other one of
               size (vector size / 8).  Vectorization factor will 8.  If both
               accesses are misaligned by 3, the first one needs one scalar
               iteration to be aligned, and the second one needs 5.  But the
 first one will be aligned also by peeling 5 scalar
               iterations, and in that case both accesses will be aligned.
               Hence, except for the immediate peeling amount, we also want
               to try to add full vector size, while we don't exceed
               vectorization factor.
               We do this automatically for cost model, since we calculate
 cost for every peeling option.  */
     poly_uint64 nscalars = npeel_tmp;
            if (unlimited_cost_model (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop))
{
  poly_uint64 vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo)(loop_vinfo)->vectorization_factor;
  nscalars = (STMT_SLP_TYPE (stmt_info)(stmt_info)->slp_type
	      ? vf * DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 1990, __FUNCTION__), 0 : 0)), (stmt_info)->size) : vf);
}

     /* Save info about DR in the hash table.  Also include peeling
 amounts according to the explanation above.  Indicate
 the alignment status when the ref is not aligned.
 ???  Rather than using unknown alignment here we should
 prune all entries from the peeling hashtable which cause
 DRs to be not supported.  */
     bool supportable_if_not_aligned
= vect_supportable_dr_alignment
    (loop_vinfo, dr_info, vectype, DR_MISALIGNMENT_UNKNOWN(-1));
     while (known_le (npeel_tmp, nscalars)(!maybe_lt (nscalars, npeel_tmp)))
              {
                vect_peeling_hash_insert (&peeling_htab, loop_vinfo,
			    dr_info, npeel_tmp,
			    supportable_if_not_aligned);
  npeel_tmp += MAX (1, target_align / dr_size)((1) > (target_align / dr_size) ? (1) : (target_align / dr_size
));
              }

     one_misalignment_known = true;
          }
        else
          {
            /* If we don't know any misalignment values, we prefer
               peeling for data-ref that has the maximum number of data-refs
               with the same alignment, unless the target prefers to align
               stores over load.  */
     unsigned same_align_drs = n_same_align_refs[i];
     if (!dr0_info
  || dr0_same_align_drs < same_align_drs)
{
  dr0_same_align_drs = same_align_drs;
  dr0_info = dr_info;
}
     /* For data-refs with the same number of related
 accesses prefer the one where the misalign
 computation will be invariant in the outermost loop.  */
     else if (dr0_same_align_drs == same_align_drs)
{
  class loop *ivloop0, *ivloop;
  ivloop0 = outermost_invariant_loop_for_expr
    (loop, DR_BASE_ADDRESS (dr0_info->dr)(dr0_info->dr)->innermost.base_address);
  ivloop = outermost_invariant_loop_for_expr
    (loop, DR_BASE_ADDRESS (dr)(dr)->innermost.base_address);
  if ((ivloop && !ivloop0)
      || (ivloop && ivloop0
	  && flow_loop_nested_p (ivloop, ivloop0)))
    dr0_info = dr_info;
}

     one_misalignment_unknown = true;

     /* Check for data refs with unsupportable alignment that
        can be peeled.  */
     enum dr_alignment_support supportable_dr_alignment
= vect_supportable_dr_alignment (loop_vinfo, dr_info, vectype,
				 DR_MISALIGNMENT_UNKNOWN(-1));
     if (supportable_dr_alignment == dr_unaligned_unsupported)
{
  one_dr_unsupportable = true;
  unsupportable_dr_info = dr_info;
}

     if (!first_store && DR_IS_WRITE (dr)(!(dr)->is_read))
{
  first_store = dr_info;
  first_store_same_align_drs = same_align_drs;
}
          }
      }
    else
      {
 if (!aligned_access_p (dr_info, vectype))
          {
            if (dump_enabled_p ())
              dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                               "vector alignment may not be reachable\n");
            break;
          }
      }
  }

/* Check if we can possibly peel the loop.  */
if (!vect_can_advance_ivs_p (loop_vinfo)
    || !slpeel_can_duplicate_loop_p (loop, single_exit (loop))
    || loop->inner)
  do_peeling = false;

struct _vect_peel_extended_info peel_for_known_alignment;
struct _vect_peel_extended_info peel_for_unknown_alignment;
struct _vect_peel_extended_info best_peel;

peel_for_unknown_alignment.inside_cost = INT_MAX2147483647;
peel_for_unknown_alignment.outside_cost = INT_MAX2147483647;
peel_for_unknown_alignment.peel_info.count = 0;

if (do_peeling
    && one_misalignment_unknown)
  {
    /* Check if the target requires to prefer stores over loads, i.e., if
       misaligned stores are more expensive than misaligned loads (taking
       drs with same alignment into account).  */
    unsigned int load_inside_cost = 0;
    unsigned int load_outside_cost = 0;
    unsigned int store_inside_cost = 0;
    unsigned int store_outside_cost = 0;
    unsigned int estimated_npeels = vect_vf_for_cost (loop_vinfo) / 2;

    stmt_vector_for_cost dummy;
    dummy.create (2);
    vect_get_peeling_costs_all_drs (loop_vinfo, dr0_info,
		      &load_inside_cost,
		      &load_outside_cost,
		      &dummy, &dummy, estimated_npeels);
    dummy.release ();

    if (first_store)
{
 dummy.create (2);
 vect_get_peeling_costs_all_drs (loop_vinfo, first_store,
			  &store_inside_cost,
			  &store_outside_cost,
			  &dummy, &dummy,
			  estimated_npeels);
 dummy.release ();
}
    else
{
 store_inside_cost = INT_MAX2147483647;
 store_outside_cost = INT_MAX2147483647;
}

    if (load_inside_cost > store_inside_cost
 || (load_inside_cost == store_inside_cost
     && load_outside_cost > store_outside_cost))
{
 dr0_info = first_store;
 dr0_same_align_drs = first_store_same_align_drs;
 peel_for_unknown_alignment.inside_cost = store_inside_cost;
 peel_for_unknown_alignment.outside_cost = store_outside_cost;
}
    else
{
 peel_for_unknown_alignment.inside_cost = load_inside_cost;
 peel_for_unknown_alignment.outside_cost = load_outside_cost;
}

    stmt_vector_for_cost prologue_cost_vec, epilogue_cost_vec;
    prologue_cost_vec.create (2);
    epilogue_cost_vec.create (2);

    int dummy2;
    peel_for_unknown_alignment.outside_cost += vect_get_known_peeling_cost
(loop_vinfo, estimated_npeels, &dummy2,
&LOOP_VINFO_SCALAR_ITERATION_COST (loop_vinfo)(loop_vinfo)->scalar_cost_vec,
&prologue_cost_vec, &epilogue_cost_vec);

    prologue_cost_vec.release ();
    epilogue_cost_vec.release ();

    peel_for_unknown_alignment.peel_info.count = dr0_same_align_drs + 1;
  }

peel_for_unknown_alignment.peel_info.npeel = 0;
peel_for_unknown_alignment.peel_info.dr_info = dr0_info;

best_peel = peel_for_unknown_alignment;

peel_for_known_alignment.inside_cost = INT_MAX2147483647;
peel_for_known_alignment.outside_cost = INT_MAX2147483647;
peel_for_known_alignment.peel_info.count = 0;
peel_for_known_alignment.peel_info.dr_info = NULLnullptr;

if (do_peeling && one_misalignment_known)
  {
    /* Peeling is possible, but there is no data access that is not supported
       unless aligned.  So we try to choose the best possible peeling from
the hash table.  */
    peel_for_known_alignment = vect_peeling_hash_choose_best_peeling
(&peeling_htab, loop_vinfo);
  }

/* Compare costs of peeling for known and unknown alignment. */
if (peel_for_known_alignment.peel_info.dr_info != NULLnullptr
    && peel_for_unknown_alignment.inside_cost
    >= peel_for_known_alignment.inside_cost)
  {
    best_peel = peel_for_known_alignment;

    /* If the best peeling for known alignment has NPEEL == 0, perform no
       peeling at all except if there is an unsupportable dr that we can
       align.  */
    if (best_peel.peel_info.npeel == 0 && !one_dr_unsupportable)
do_peeling = false;
  }

/* If there is an unsupportable data ref, prefer this over all choices so far
   since we'd have to discard a chosen peeling except when it accidentally
   aligned the unsupportable data ref.  */
if (one_dr_unsupportable)
  dr0_info = unsupportable_dr_info;
else if (do_peeling)
  {
    /* Calculate the penalty for no peeling, i.e. leaving everything as-is.
TODO: Use nopeel_outside_cost or get rid of it?  */
    unsigned nopeel_inside_cost = 0;
    unsigned nopeel_outside_cost = 0;

    stmt_vector_for_cost dummy;
    dummy.create (2);
    vect_get_peeling_costs_all_drs (loop_vinfo, NULLnullptr, &nopeel_inside_cost,
		      &nopeel_outside_cost, &dummy, &dummy, 0);
    dummy.release ();

    /* Add epilogue costs.  As we do not peel for alignment here, no prologue
costs will be recorded.  */
    stmt_vector_for_cost prologue_cost_vec, epilogue_cost_vec;
    prologue_cost_vec.create (2);
    epilogue_cost_vec.create (2);

    int dummy2;
    nopeel_outside_cost += vect_get_known_peeling_cost
(loop_vinfo, 0, &dummy2,
&LOOP_VINFO_SCALAR_ITERATION_COST (loop_vinfo)(loop_vinfo)->scalar_cost_vec,
&prologue_cost_vec, &epilogue_cost_vec);

    prologue_cost_vec.release ();
    epilogue_cost_vec.release ();

    npeel = best_peel.peel_info.npeel;
    dr0_info = best_peel.peel_info.dr_info;

    /* If no peeling is not more expensive than the best peeling we
have so far, don't perform any peeling.  */
    if (nopeel_inside_cost <= best_peel.inside_cost)
do_peeling = false;
  }

if (do_peeling)
  {
    stmt_vec_info stmt_info = dr0_info->stmt;
    if (known_alignment_for_access_p (dr0_info,
			STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype))
      {
 bool negative = tree_int_cst_compare (DR_STEP (dr0_info->dr)(dr0_info->dr)->innermost.step,
				size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0;
        if (!npeel)
          {
            /* Since it's known at compile time, compute the number of
               iterations in the peeled loop (the peeling factor) for use in
               updating DR_MISALIGNMENT values.  The peeling factor is the
               vectorization factor minus the misalignment as an element
               count.  */
     tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;
     poly_int64 off = 0;
     if (negative)
off = ((TYPE_VECTOR_SUBPARTS (vectype) - 1)
       * -TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2248, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2248, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2248, __FUNCTION__))));
     unsigned int mis
= dr_misalignment (dr0_info, vectype, off);
     mis = negative ? mis : -mis;
     /* If known_alignment_for_access_p then we have set
        DR_MISALIGNMENT which is only done if we know it at compiler
        time, so it is safe to assume target alignment is constant.
      */
     unsigned int target_align =
DR_TARGET_ALIGNMENT (dr0_info)dr_target_alignment (dr0_info).to_constant ();
     npeel = ((mis & (target_align - 1))
       / vect_get_scalar_dr_size (dr0_info));
          }

 /* For interleaved data access every iteration accesses all the
    members of the group, therefore we divide the number of iterations
    by the group size.  */
 if (STMT_VINFO_GROUPED_ACCESS (stmt_info)((stmt_info)->dr_aux.dr && (((void)(!((stmt_info)->
dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2265, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
)))
   npeel /= DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2266, __FUNCTION__), 0 : 0)), (stmt_info)->size);

        if (dump_enabled_p ())
          dump_printf_loc (MSG_NOTE, vect_location,
                           "Try peeling by %d\n", npeel);
      }

    /* Ensure that all datarefs can be vectorized after the peel.  */
    if (!vect_peeling_supportable (loop_vinfo, dr0_info, npeel))
do_peeling = false;

    /* Check if all datarefs are supportable and log.  */
    if (do_peeling
 && npeel == 0
 && known_alignment_for_access_p (dr0_info,
			   STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype))
return opt_result::success ();

    /* Cost model #1 - honor --param vect-max-peeling-for-alignment.  */
    if (do_peeling)
      {
        unsigned max_allowed_peel
   = param_vect_max_peeling_for_alignmentglobal_options.x_param_vect_max_peeling_for_alignment;
 if (loop_cost_model (loop) <= VECT_COST_MODEL_CHEAP)
   max_allowed_peel = 0;
        if (max_allowed_peel != (unsigned)-1)
          {
            unsigned max_peel = npeel;
            if (max_peel == 0)
              {
  poly_uint64 target_align = DR_TARGET_ALIGNMENT (dr0_info)dr_target_alignment (dr0_info);
  unsigned HOST_WIDE_INTlong target_align_c;
  if (target_align.is_constant (&target_align_c))
    max_peel =
      target_align_c / vect_get_scalar_dr_size (dr0_info) - 1;
  else
    {
      do_peeling = false;
      if (dump_enabled_p ())
	dump_printf_loc (MSG_NOTE, vect_location,
	  "Disable peeling, max peels set and vector"
	  " alignment unknown\n");
    }
              }
            if (max_peel > max_allowed_peel)
              {
                do_peeling = false;
                if (dump_enabled_p ())
                  dump_printf_loc (MSG_NOTE, vect_location,
                      "Disable peeling, max peels reached: %d\n", max_peel);
              }
          }
      }

    /* Cost model #2 - if peeling may result in a remaining loop not
iterating enough to be vectorized then do not peel.  Since this
is a cost heuristic rather than a correctness decision, use the
most likely runtime value for variable vectorization factors.  */
    if (do_peeling
 && LOOP_VINFO_NITERS_KNOWN_P (loop_vinfo)(tree_fits_shwi_p ((loop_vinfo)->num_iters) && tree_to_shwi
 ((loop_vinfo)->num_iters) > 0))
{
 unsigned int assumed_vf = vect_vf_for_cost (loop_vinfo);
 unsigned int max_peel = npeel == 0 ? assumed_vf - 1 : npeel;
 if ((unsigned HOST_WIDE_INTlong) LOOP_VINFO_INT_NITERS (loop_vinfo)(((unsigned long) (*tree_int_cst_elt_check (((loop_vinfo)->
num_iters), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2329, __FUNCTION__))))
     < assumed_vf + max_peel)
   do_peeling = false;
}

    if (do_peeling)
      {
        /* (1.2) Update the DR_MISALIGNMENT of each data reference DR_i.
           If the misalignment of DR_i is identical to that of dr0 then set
           DR_MISALIGNMENT (DR_i) to zero.  If the misalignment of DR_i and
           dr0 are known at compile time then increment DR_MISALIGNMENT (DR_i)
           by the peeling factor times the element size of DR_i (MOD the
           vectorization factor times the size).  Otherwise, the
           misalignment of DR_i must be set to unknown.  */
 FOR_EACH_VEC_ELT (datarefs, i, dr)for (i = 0; (datarefs).iterate ((i), &(dr)); ++(i))
   if (dr != dr0_info->dr)
     {
dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
if (!vect_relevant_for_alignment_p (dr_info))
  continue;

vect_update_misalignment_for_peel (dr_info, dr0_info, npeel);
     }

        LOOP_VINFO_UNALIGNED_DR (loop_vinfo)(loop_vinfo)->unaligned_dr = dr0_info;
        if (npeel)
          LOOP_VINFO_PEELING_FOR_ALIGNMENT (loop_vinfo)(loop_vinfo)->peeling_for_alignment = npeel;
        else
   LOOP_VINFO_PEELING_FOR_ALIGNMENT (loop_vinfo)(loop_vinfo)->peeling_for_alignment = -1;
 SET_DR_MISALIGNMENT (dr0_info,set_dr_misalignment (dr0_info, vect_dr_misalign_for_aligned_access
 (dr0_info))
	       vect_dr_misalign_for_aligned_access (dr0_info))set_dr_misalignment (dr0_info, vect_dr_misalign_for_aligned_access
 (dr0_info));
 if (dump_enabled_p ())
          {
            dump_printf_loc (MSG_NOTE, vect_location,
                             "Alignment of access forced using peeling.\n");
            dump_printf_loc (MSG_NOTE, vect_location,
                             "Peeling for alignment will be applied.\n");
          }

 /* The inside-loop cost will be accounted for in vectorizable_load
    and vectorizable_store correctly with adjusted alignments.
    Drop the body_cst_vec on the floor here.  */
 return opt_result::success ();
      }
  }

/* (2) Versioning to force alignment.  */

/* Try versioning if:
   1) optimize loop for speed and the cost-model is not cheap
   2) there is at least one unsupported misaligned data ref with an unknown
      misalignment, and
   3) all misaligned data refs with a known misalignment are supported, and
   4) the number of runtime alignment checks is within reason.  */

do_versioning
  = (optimize_loop_nest_for_speed_p (loop)
     && !loop->inner /* FORNOW */
     && loop_cost_model (loop) > VECT_COST_MODEL_CHEAP);

if (do_versioning)
  {
    FOR_EACH_VEC_ELT (datarefs, i, dr)for (i = 0; (datarefs).iterate ((i), &(dr)); ++(i))
      {
 dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
 if (!vect_relevant_for_alignment_p (dr_info))
   continue;

 stmt_vec_info stmt_info = dr_info->stmt;
 if (STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p)
   {
     do_versioning = false;
     break;
   }

 tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;
 bool negative = tree_int_cst_compare (DR_STEP (dr)(dr)->innermost.step,
				size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0;
 poly_int64 off = 0;
 if (negative)
   off = ((TYPE_VECTOR_SUBPARTS (vectype) - 1)
   * -TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (vectype)))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2410, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2410, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2410, __FUNCTION__))));
 int misalignment;
 if ((misalignment = dr_misalignment (dr_info, vectype, off)) == 0)
   continue;

 enum dr_alignment_support supportable_dr_alignment
   = vect_supportable_dr_alignment (loop_vinfo, dr_info, vectype,
			     misalignment);
 if (supportable_dr_alignment == dr_unaligned_unsupported)
          {
     if (misalignment != DR_MISALIGNMENT_UNKNOWN(-1)
  || (LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)(loop_vinfo)->may_misalign_stmts.length ()
      >= (unsigned) param_vect_max_version_for_alignment_checksglobal_options.x_param_vect_max_version_for_alignment_checks))
              {
                do_versioning = false;
                break;
              }

     /* At present we don't support versioning for alignment
 with variable VF, since there's no guarantee that the
 VF is a power of two.  We could relax this if we added
 a way of enforcing a power-of-two size.  */
     unsigned HOST_WIDE_INTlong size;
     if (!GET_MODE_SIZE (TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2433, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (vectype) : (vectype)->type_common.mode)).is_constant (&size))
{
  do_versioning = false;
  break;
}

     /* Forcing alignment in the first iteration is no good if
 we don't keep it across iterations.  For now, just disable
 versioning in this case.
 ?? We could actually unroll the loop to achieve the required
 overall step alignment, and forcing the alignment could be
 done by doing some iterations of the non-vectorized loop.  */
     if (!multiple_p (LOOP_VINFO_VECT_FACTOR (loop_vinfo)(loop_vinfo)->vectorization_factor
	       * DR_STEP_ALIGNMENT (dr)(dr)->innermost.step_alignment,
	       DR_TARGET_ALIGNMENT (dr_info)dr_target_alignment (dr_info)))
{
  do_versioning = false;
  break;
}

            /* The rightmost bits of an aligned address must be zeros.
               Construct the mask needed for this test.  For example,
               GET_MODE_SIZE for the vector mode V4SI is 16 bytes so the
               mask must be 15 = 0xf. */
     int mask = size - 1;

     /* FORNOW: use the same mask to test all potentially unaligned
 references in the loop.  */
     if (LOOP_VINFO_PTR_MASK (loop_vinfo)(loop_vinfo)->ptr_mask
  && LOOP_VINFO_PTR_MASK (loop_vinfo)(loop_vinfo)->ptr_mask != mask)
{
  do_versioning = false;
  break;
}

            LOOP_VINFO_PTR_MASK (loop_vinfo)(loop_vinfo)->ptr_mask = mask;
     LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)(loop_vinfo)->may_misalign_stmts.safe_push (stmt_info);
          }
      }

    /* Versioning requires at least one misaligned data reference.  */
    if (!LOOP_REQUIRES_VERSIONING_FOR_ALIGNMENT (loop_vinfo)((loop_vinfo)->may_misalign_stmts.length () > 0))
      do_versioning = false;
    else if (!do_versioning)
      LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)(loop_vinfo)->may_misalign_stmts.truncate (0);
  }

if (do_versioning)
  {
    const vec<stmt_vec_info> &may_misalign_stmts
= LOOP_VINFO_MAY_MISALIGN_STMTS (loop_vinfo)(loop_vinfo)->may_misalign_stmts;
    stmt_vec_info stmt_info;

    /* It can now be assumed that the data references in the statements
       in LOOP_VINFO_MAY_MISALIGN_STMTS will be aligned in the version
       of the loop being vectorized.  */
    FOR_EACH_VEC_ELT (may_misalign_stmts, i, stmt_info)for (i = 0; (may_misalign_stmts).iterate ((i), &(stmt_info
)); ++(i))
      {
 dr_vec_info *dr_info = STMT_VINFO_DR_INFO (stmt_info)(((void)(!((stmt_info)->dr_aux.stmt == (stmt_info)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2491, __FUNCTION__), 0 : 0)), &(stmt_info)->dr_aux);
 SET_DR_MISALIGNMENT (dr_info,set_dr_misalignment (dr_info, vect_dr_misalign_for_aligned_access
 (dr_info))
	       vect_dr_misalign_for_aligned_access (dr_info))set_dr_misalignment (dr_info, vect_dr_misalign_for_aligned_access
 (dr_info));
 if (dump_enabled_p ())
          dump_printf_loc (MSG_NOTE, vect_location,
                           "Alignment of access forced using versioning.\n");
      }

    if (dump_enabled_p ())
      dump_printf_loc (MSG_NOTE, vect_location,
                       "Versioning for alignment will be applied.\n");

    /* Peeling and versioning can't be done together at this time.  */
    gcc_assert (! (do_peeling && do_versioning))((void)(!(! (do_peeling && do_versioning)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2504, __FUNCTION__), 0 : 0));

    return opt_result::success ();
  }

/* This point is reached if neither peeling nor versioning is being done.  */
gcc_assert (! (do_peeling || do_versioning))((void)(!(! (do_peeling || do_versioning)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2510, __FUNCTION__), 0 : 0));

return opt_result::success ();
2513}


2516/* Function vect_analyze_data_refs_alignment

 Analyze the alignment of the data-references in the loop.
 Return FALSE if a data reference is found that cannot be vectorized.  */

2521opt_result
2522vect_analyze_data_refs_alignment (loop_vec_info loop_vinfo)
2523{
DUMP_VECT_SCOPE ("vect_analyze_data_refs_alignment")auto_dump_scope scope ("vect_analyze_data_refs_alignment", vect_location
);

vec<data_reference_p> datarefs = LOOP_VINFO_DATAREFS (loop_vinfo)(loop_vinfo)->shared->datarefs;
struct data_reference *dr;
unsigned int i;

vect_record_base_alignments (loop_vinfo);
FOR_EACH_VEC_ELT (datarefs, i, dr)for (i = 0; (datarefs).iterate ((i), &(dr)); ++(i))
  {
    dr_vec_info *dr_info = loop_vinfo->lookup_dr (dr);
    if (STMT_VINFO_VECTORIZABLE (dr_info->stmt)(dr_info->stmt)->vectorizable)
{
 if (STMT_VINFO_GROUPED_ACCESS (dr_info->stmt)((dr_info->stmt)->dr_aux.dr && (((void)(!((dr_info
->stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2536, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
))
     && DR_GROUP_FIRST_ELEMENT (dr_info->stmt)(((void)(!((dr_info->stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2537, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
) != dr_info->stmt)
   continue;
 vect_compute_data_ref_alignment (loop_vinfo, dr_info,
			   STMT_VINFO_VECTYPE (dr_info->stmt)(dr_info->stmt)->vectype);
}
  }

return opt_result::success ();
2545}


2548/* Analyze alignment of DRs of stmts in NODE.  */

2550static bool
2551vect_slp_analyze_node_alignment (vec_info *vinfo, slp_tree node)
2552{
/* Alignment is maintained in the first element of the group.  */
stmt_vec_info first_stmt_info = SLP_TREE_SCALAR_STMTS (node)(node)->stmts[0];
first_stmt_info = DR_GROUP_FIRST_ELEMENT (first_stmt_info)(((void)(!((first_stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2555, __FUNCTION__), 0 : 0)), (first_stmt_info)->first_element
);
dr_vec_info *dr_info = STMT_VINFO_DR_INFO (first_stmt_info)(((void)(!((first_stmt_info)->dr_aux.stmt == (first_stmt_info
)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2556, __FUNCTION__), 0 : 0)), &(first_stmt_info)->dr_aux
);
tree vectype = SLP_TREE_VECTYPE (node)(node)->vectype;
poly_uint64 vector_alignment
  = exact_div (targetm.vectorize.preferred_vector_alignment (vectype),
 BITS_PER_UNIT(8));
if (dr_info->misalignment == DR_MISALIGNMENT_UNINITIALIZED(-2))
  vect_compute_data_ref_alignment (vinfo, dr_info, SLP_TREE_VECTYPE (node)(node)->vectype);
/* Re-analyze alignment when we're facing a vectorization with a bigger
   alignment requirement.  */
else if (known_lt (dr_info->target_alignment, vector_alignment)(!maybe_le (vector_alignment, dr_info->target_alignment)))
  {
    poly_uint64 old_target_alignment = dr_info->target_alignment;
    int old_misalignment = dr_info->misalignment;
    vect_compute_data_ref_alignment (vinfo, dr_info, SLP_TREE_VECTYPE (node)(node)->vectype);
    /* But keep knowledge about a smaller alignment.  */
    if (old_misalignment != DR_MISALIGNMENT_UNKNOWN(-1)
 && dr_info->misalignment == DR_MISALIGNMENT_UNKNOWN(-1))
{
 dr_info->target_alignment = old_target_alignment;
 dr_info->misalignment = old_misalignment;
}
  }
/* When we ever face unordered target alignments the first one wins in terms
   of analyzing and the other will become unknown in dr_misalignment.  */
return true;
2581}

2583/* Function vect_slp_analyze_instance_alignment

 Analyze the alignment of the data-references in the SLP instance.
 Return FALSE if a data reference is found that cannot be vectorized.  */

2588bool
2589vect_slp_analyze_instance_alignment (vec_info *vinfo,
				slp_instance instance)
2591{
DUMP_VECT_SCOPE ("vect_slp_analyze_instance_alignment")auto_dump_scope scope ("vect_slp_analyze_instance_alignment",
 vect_location);

slp_tree node;
unsigned i;
FOR_EACH_VEC_ELT (SLP_INSTANCE_LOADS (instance), i, node)for (i = 0; ((instance)->loads).iterate ((i), &(node))
; ++(i))
  if (! vect_slp_analyze_node_alignment (vinfo, node))
    return false;

if (SLP_INSTANCE_KIND (instance)(instance)->kind == slp_inst_kind_store
    && ! vect_slp_analyze_node_alignment
    (vinfo, SLP_INSTANCE_TREE (instance)(instance)->root))
  return false;

return true;
2606}


2609/* Analyze groups of accesses: check that DR_INFO belongs to a group of
 accesses of legal size, step, etc.  Detect gaps, single element
 interleaving, and other special cases. Set grouped access info.
 Collect groups of strided stores for further use in SLP analysis.
 Worker for vect_analyze_group_access.  */

2615static bool
2616vect_analyze_group_access_1 (vec_info *vinfo, dr_vec_info *dr_info)
2617{
data_reference *dr = dr_info->dr;
tree step = DR_STEP (dr)(dr)->innermost.step;
tree scalar_type = TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2620, __FUNCTION__))->typed.type);
HOST_WIDE_INTlong type_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (scalar_type))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((scalar_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2621, __FUNCTION__))->type_common.size_unit)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2621, __FUNCTION__)));
stmt_vec_info stmt_info = dr_info->stmt;
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo);
HOST_WIDE_INTlong dr_step = -1;
HOST_WIDE_INTlong groupsize, last_accessed_element = 1;
bool slp_impossible = false;

/* For interleaving, GROUPSIZE is STEP counted in elements, i.e., the
   size of the interleaving group (including gaps).  */
if (tree_fits_shwi_p (step))
  {
    dr_step = tree_to_shwi (step);
    /* Check that STEP is a multiple of type size.  Otherwise there is
       a non-element-sized gap at the end of the group which we
cannot represent in DR_GROUP_GAP or DR_GROUP_SIZE.
???  As we can handle non-constant step fine here we should
simply remove uses of DR_GROUP_GAP between the last and first
element and instead rely on DR_STEP.  DR_GROUP_SIZE then would
simply not include that gap.  */
    if ((dr_step % type_size) != 0)
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "Step %T is not a multiple of the element size"
	     " for %T\n",
	     step, DR_REF (dr)(dr)->ref);
 return false;
}
    groupsize = absu_hwi (dr_step) / type_size;
  }
else
  groupsize = 0;

/* Not consecutive access is possible only if it is a part of interleaving.  */
if (!DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2656, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))
  {
    /* Check if it this DR is a part of interleaving, and is a single
element of the group that is accessed in the loop.  */

    /* Gaps are supported only for loads. STEP must be a multiple of the type
size.  */
    if (DR_IS_READ (dr)(dr)->is_read
 && (dr_step % type_size) == 0
 && groupsize > 0
 /* This could be UINT_MAX but as we are generating code in a very
    inefficient way we have to cap earlier.
    See PR91403 for example.  */
 && groupsize <= 4096)
{
 DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2671, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) = stmt_info;
 DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2672, __FUNCTION__), 0 : 0)), (stmt_info)->size) = groupsize;
 DR_GROUP_GAP (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2673, __FUNCTION__), 0 : 0)), (stmt_info)->gap) = groupsize - 1;
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "Detected single element interleaving %T"
	     " step %T\n",
	     DR_REF (dr)(dr)->ref, step);

 return true;
}

    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	 "not consecutive access %G", stmt_info->stmt);

    if (bb_vinfo)
{
 /* Mark the statement as unvectorizable.  */
 STMT_VINFO_VECTORIZABLE (stmt_info)(stmt_info)->vectorizable = false;
 return true;
}

    if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location, "using strided accesses\n");
    STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p = true;
    return true;
  }

if (DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2700, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) == stmt_info)
  {
    /* First stmt in the interleaving chain. Check the chain.  */
    stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2703, __FUNCTION__), 0 : 0)), (stmt_info)->next_element);
    struct data_reference *data_ref = dr;
    unsigned int count = 1;
    tree prev_init = DR_INIT (data_ref)(data_ref)->innermost.init;
    HOST_WIDE_INTlong diff, gaps = 0;

    /* By construction, all group members have INTEGER_CST DR_INITs.  */
    while (next)
      {
        /* We never have the same DR multiple times.  */
        gcc_assert (tree_int_cst_compare (DR_INIT (data_ref),((void)(!(tree_int_cst_compare ((data_ref)->innermost.init
, (((next)->dr_aux.dr + 0))->innermost.init) != 0) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2714, __FUNCTION__), 0 : 0))
		DR_INIT (STMT_VINFO_DATA_REF (next))) != 0)((void)(!(tree_int_cst_compare ((data_ref)->innermost.init
, (((next)->dr_aux.dr + 0))->innermost.init) != 0) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2714, __FUNCTION__), 0 : 0));

 data_ref = STMT_VINFO_DATA_REF (next)((next)->dr_aux.dr + 0);

 /* All group members have the same STEP by construction.  */
 gcc_checking_assert (operand_equal_p (DR_STEP (data_ref), step, 0))((void)(!(operand_equal_p ((data_ref)->innermost.step, step
, 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2719, __FUNCTION__), 0 : 0));

        /* Check that the distance between two accesses is equal to the type
           size. Otherwise, we have gaps.  */
        diff = (TREE_INT_CST_LOW (DR_INIT (data_ref))((unsigned long) (*tree_int_cst_elt_check (((data_ref)->innermost
.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2723, __FUNCTION__)))
  - TREE_INT_CST_LOW (prev_init)((unsigned long) (*tree_int_cst_elt_check ((prev_init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2724, __FUNCTION__)))) / type_size;
 if (diff < 1 || diff > UINT_MAX(2147483647 *2U +1U))
   {
     /* For artificial testcases with array accesses with large
 constant indices we can run into overflow issues which
 can end up fooling the groupsize constraint below so
 check the individual gaps (which are represented as
 unsigned int) as well.  */
     if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
		 "interleaved access with gap larger "
		 "than representable\n");
     return false;
   }
 if (diff != 1)
   {
     /* FORNOW: SLP of accesses with gaps is not supported.  */
     slp_impossible = true;
     if (DR_IS_WRITE (data_ref)(!(data_ref)->is_read))
{
                if (dump_enabled_p ())
                  dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                                   "interleaved store with gaps\n");
  return false;
}

            gaps += diff - 1;
   }

 last_accessed_element += diff;

        /* Store the gap from the previous member of the group. If there is no
           gap in the access, DR_GROUP_GAP is always 1.  */
 DR_GROUP_GAP (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2757, __FUNCTION__), 0 : 0)), (next)->gap) = diff;

 prev_init = DR_INIT (data_ref)(data_ref)->innermost.init;
 next = DR_GROUP_NEXT_ELEMENT (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2760, __FUNCTION__), 0 : 0)), (next)->next_element);
 /* Count the number of data-refs in the chain.  */
 count++;
      }

    if (groupsize == 0)
      groupsize = count + gaps;

    /* This could be UINT_MAX but as we are generating code in a very
       inefficient way we have to cap earlier.  See PR78699 for example.  */
    if (groupsize > 4096)
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	     "group is too large\n");
 return false;
}

    /* Check that the size of the interleaving is equal to count for stores,
       i.e., that there are no gaps.  */
    if (groupsize != count
 && !DR_IS_READ (dr)(dr)->is_read)
      {
 groupsize = count;
 STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p = true;
}

    /* If there is a gap after the last load in the group it is the
difference between the groupsize and the last accessed
element.
When there is no gap, this difference should be 0.  */
    DR_GROUP_GAP (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2791, __FUNCTION__), 0 : 0)), (stmt_info)->gap) = groupsize - last_accessed_element;

    DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2793, __FUNCTION__), 0 : 0)), (stmt_info)->size) = groupsize;
    if (dump_enabled_p ())
{
 dump_printf_loc (MSG_NOTE, vect_location,
	   "Detected interleaving ");
 if (DR_IS_READ (dr)(dr)->is_read)
   dump_printf (MSG_NOTE, "load ");
 else if (STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p)
   dump_printf (MSG_NOTE, "strided store ");
 else
   dump_printf (MSG_NOTE, "store ");
 dump_printf (MSG_NOTE, "of size %u\n",
       (unsigned)groupsize);
 dump_printf_loc (MSG_NOTE, vect_location, "\t%G", stmt_info->stmt);
 next = DR_GROUP_NEXT_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2807, __FUNCTION__), 0 : 0)), (stmt_info)->next_element);
 while (next)
   {
     if (DR_GROUP_GAP (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2810, __FUNCTION__), 0 : 0)), (next)->gap) != 1)
dump_printf_loc (MSG_NOTE, vect_location,
		 "\t<gap of %d elements>\n",
		 DR_GROUP_GAP (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2813, __FUNCTION__), 0 : 0)), (next)->gap) - 1);
     dump_printf_loc (MSG_NOTE, vect_location, "\t%G", next->stmt);
     next = DR_GROUP_NEXT_ELEMENT (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2815, __FUNCTION__), 0 : 0)), (next)->next_element);
   }
 if (DR_GROUP_GAP (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2817, __FUNCTION__), 0 : 0)), (stmt_info)->gap) != 0)
   dump_printf_loc (MSG_NOTE, vect_location,
	     "\t<gap of %d elements>\n",
	     DR_GROUP_GAP (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2820, __FUNCTION__), 0 : 0)), (stmt_info)->gap));
}

    /* SLP: create an SLP data structure for every interleaving group of
stores for further analysis in vect_analyse_slp.  */
    if (DR_IS_WRITE (dr)(!(dr)->is_read) && !slp_impossible)
{
 if (loop_vinfo)
   LOOP_VINFO_GROUPED_STORES (loop_vinfo)(loop_vinfo)->grouped_stores.safe_push (stmt_info);
 if (bb_vinfo)
   BB_VINFO_GROUPED_STORES (bb_vinfo)(bb_vinfo)->grouped_stores.safe_push (stmt_info);
}
  }

return true;
2835}

2837/* Analyze groups of accesses: check that DR_INFO belongs to a group of
 accesses of legal size, step, etc.  Detect gaps, single element
 interleaving, and other special cases. Set grouped access info.
 Collect groups of strided stores for further use in SLP analysis.  */

2842static bool
2843vect_analyze_group_access (vec_info *vinfo, dr_vec_info *dr_info)
2844{
if (!vect_analyze_group_access_1 (vinfo, dr_info))
  {
    /* Dissolve the group if present.  */
    stmt_vec_info stmt_info = DR_GROUP_FIRST_ELEMENT (dr_info->stmt)(((void)(!((dr_info->stmt)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2848, __FUNCTION__), 0 : 0)), (dr_info->stmt)->first_element
);
    while (stmt_info)
{
 stmt_vec_info next = DR_GROUP_NEXT_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2851, __FUNCTION__), 0 : 0)), (stmt_info)->next_element);
 DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2852, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) = NULLnullptr;
 DR_GROUP_NEXT_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2853, __FUNCTION__), 0 : 0)), (stmt_info)->next_element) = NULLnullptr;
 stmt_info = next;
}
    return false;
  }
return true;
2859}

2861/* Analyze the access pattern of the data-reference DR_INFO.
 In case of non-consecutive accesses call vect_analyze_group_access() to
 analyze groups of accesses.  */

2865static bool
2866vect_analyze_data_ref_access (vec_info *vinfo, dr_vec_info *dr_info)
2867{
data_reference *dr = dr_info->dr;
tree step = DR_STEP (dr)(dr)->innermost.step;
tree scalar_type = TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2870, __FUNCTION__))->typed.type);
stmt_vec_info stmt_info = dr_info->stmt;
loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo);
class loop *loop = NULLnullptr;

if (STMT_VINFO_GATHER_SCATTER_P (stmt_info)(stmt_info)->gather_scatter_p)
  return true;

if (loop_vinfo)
  loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;

if (loop_vinfo && !step)
  {
    if (dump_enabled_p ())
dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
                "bad data-ref access in loop\n");
    return false;
  }

/* Allow loads with zero step in inner-loop vectorization.  */
if (loop_vinfo && integer_zerop (step))
  {
    DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2892, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) = NULLnullptr;
    if (!nested_in_vect_loop_p (loop, stmt_info))
return DR_IS_READ (dr)(dr)->is_read;
    /* Allow references with zero step for outer loops marked
with pragma omp simd only - it guarantees absence of
loop-carried dependencies between inner loop iterations.  */
    if (loop->safelen < 2)
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "zero step in inner loop of nest\n");
 return false;
}
  }

if (loop && nested_in_vect_loop_p (loop, stmt_info))
  {
    /* Interleaved accesses are not yet supported within outer-loop
      vectorization for references in the inner-loop.  */
    DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2911, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) = NULLnullptr;

    /* For the rest of the analysis we use the outer-loop step.  */
    step = STMT_VINFO_DR_STEP (stmt_info)(stmt_info)->dr_wrt_vec_loop.step;
    if (integer_zerop (step))
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
                    "zero step in outer loop.\n");
 return DR_IS_READ (dr)(dr)->is_read;
}
  }

/* Consecutive?  */
if (TREE_CODE (step)((enum tree_code) (step)->base.code) == INTEGER_CST)
  {
    HOST_WIDE_INTlong dr_step = TREE_INT_CST_LOW (step)((unsigned long) (*tree_int_cst_elt_check ((step), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2927, __FUNCTION__)));
    if (!tree_int_cst_compare (step, TYPE_SIZE_UNIT (scalar_type)((tree_class_check ((scalar_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2928, __FUNCTION__))->type_common.size_unit))
 || (dr_step < 0
     && !compare_tree_int (TYPE_SIZE_UNIT (scalar_type)((tree_class_check ((scalar_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2930, __FUNCTION__))->type_common.size_unit), -dr_step)))
{
 /* Mark that it is not interleaving.  */
 DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2933, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
) = NULLnullptr;
 return true;
}
  }

if (loop && nested_in_vect_loop_p (loop, stmt_info))
  {
    if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
                "grouped access in outer loop.\n");
    return false;
  }


/* Assume this is a DR handled by non-constant strided load case.  */
if (TREE_CODE (step)((enum tree_code) (step)->base.code) != INTEGER_CST)
  return (STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p
   && (!STMT_VINFO_GROUPED_ACCESS (stmt_info)((stmt_info)->dr_aux.dr && (((void)(!((stmt_info)->
dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2950, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))
|| vect_analyze_group_access (vinfo, dr_info)));

/* Not consecutive access - check if it's a part of interleaving group.  */
return vect_analyze_group_access (vinfo, dr_info);
2955}

2957/* Compare two data-references DRA and DRB to group them into chunks
 suitable for grouping.  */

2960static int
2961dr_group_sort_cmp (const void *dra_, const void *drb_)
2962{
dr_vec_info *dra_info = *(dr_vec_info **)const_cast<void *>(dra_);
dr_vec_info *drb_info = *(dr_vec_info **)const_cast<void *>(drb_);
data_reference_p dra = dra_info->dr;
data_reference_p drb = drb_info->dr;
int cmp;

/* Stabilize sort.  */
if (dra == drb)
  return 0;

/* Different group IDs lead never belong to the same group.  */
if (dra_info->group != drb_info->group)
  return dra_info->group < drb_info->group ? -1 : 1;

/* Ordering of DRs according to base.  */
cmp = data_ref_compare_tree (DR_BASE_ADDRESS (dra)(dra)->innermost.base_address,
	       DR_BASE_ADDRESS (drb)(drb)->innermost.base_address);
if (cmp != 0)
  return cmp;

/* And according to DR_OFFSET.  */
cmp = data_ref_compare_tree (DR_OFFSET (dra)(dra)->innermost.offset, DR_OFFSET (drb)(drb)->innermost.offset);
if (cmp != 0)
  return cmp;

/* Put reads before writes.  */
if (DR_IS_READ (dra)(dra)->is_read != DR_IS_READ (drb)(drb)->is_read)
  return DR_IS_READ (dra)(dra)->is_read ? -1 : 1;

/* Then sort after access size.  */
cmp = data_ref_compare_tree (TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra)))((tree_class_check ((((contains_struct_check (((dra)->ref)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2993, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2993, __FUNCTION__))->type_common.size_unit),
	       TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb)))((tree_class_check ((((contains_struct_check (((drb)->ref)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2994, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 2994, __FUNCTION__))->type_common.size_unit));
if (cmp != 0)
  return cmp;

/* And after step.  */
cmp = data_ref_compare_tree (DR_STEP (dra)(dra)->innermost.step, DR_STEP (drb)(drb)->innermost.step);
if (cmp != 0)
  return cmp;

/* Then sort after DR_INIT.  In case of identical DRs sort after stmt UID.  */
cmp = data_ref_compare_tree (DR_INIT (dra)(dra)->innermost.init, DR_INIT (drb)(drb)->innermost.init);
if (cmp == 0)
  return gimple_uid (DR_STMT (dra)(dra)->stmt) < gimple_uid (DR_STMT (drb)(drb)->stmt) ? -1 : 1;
return cmp;
3008}

3010/* If OP is the result of a conversion, return the unconverted value,
 otherwise return null.  */

3013static tree
3014strip_conversion (tree op)
3015{
if (TREE_CODE (op)((enum tree_code) (op)->base.code) != SSA_NAME)
  return NULL_TREE(tree) nullptr;
gimple *stmt = SSA_NAME_DEF_STMT (op)(tree_check ((op), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3018, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt;
if (!is_gimple_assign (stmt)
    || !CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt))((gimple_assign_rhs_code (stmt)) == NOP_EXPR || (gimple_assign_rhs_code
 (stmt)) == CONVERT_EXPR))
  return NULL_TREE(tree) nullptr;
return gimple_assign_rhs1 (stmt);
3023}

3025/* Return true if vectorizable_* routines can handle statements STMT1_INFO
 and STMT2_INFO being in a single group.  When ALLOW_SLP_P, masked loads can
 be grouped in SLP mode.  */

3029static bool
3030can_group_stmts_p (stmt_vec_info stmt1_info, stmt_vec_info stmt2_info,
   bool allow_slp_p)
3032{
if (gimple_assign_single_p (stmt1_info->stmt))
  return gimple_assign_single_p (stmt2_info->stmt);

gcall *call1 = dyn_cast <gcall *> (stmt1_info->stmt);
if (call1 && gimple_call_internal_p (call1))
  {
    /* Check for two masked loads or two masked stores.  */
    gcall *call2 = dyn_cast <gcall *> (stmt2_info->stmt);
    if (!call2 || !gimple_call_internal_p (call2))
return false;
    internal_fn ifn = gimple_call_internal_fn (call1);
    if (ifn != IFN_MASK_LOAD && ifn != IFN_MASK_STORE)
return false;
    if (ifn != gimple_call_internal_fn (call2))
return false;

    /* Check that the masks are the same.  Cope with casts of masks,
like those created by build_mask_conversion.  */
    tree mask1 = gimple_call_arg (call1, 2);
    tree mask2 = gimple_call_arg (call2, 2);
    if (!operand_equal_p (mask1, mask2, 0)
        && (ifn == IFN_MASK_STORE || !allow_slp_p))
{
 mask1 = strip_conversion (mask1);
 if (!mask1)
   return false;
 mask2 = strip_conversion (mask2);
 if (!mask2)
   return false;
 if (!operand_equal_p (mask1, mask2, 0))
   return false;
}
    return true;
  }

return false;
3069}

3071/* Function vect_analyze_data_ref_accesses.

 Analyze the access pattern of all the data references in the loop.

 FORNOW: the only access pattern that is considered vectorizable is a
  simple step 1 (consecutive) access.

 FORNOW: handle only arrays and pointer accesses.  */

3080opt_result
3081vect_analyze_data_ref_accesses (vec_info *vinfo,
		vec<int> *dataref_groups)
3083{
unsigned int i;
vec<data_reference_p> datarefs = vinfo->shared->datarefs;

DUMP_VECT_SCOPE ("vect_analyze_data_ref_accesses")auto_dump_scope scope ("vect_analyze_data_ref_accesses", vect_location
);

if (datarefs.is_empty ())
  return opt_result::success ();

/* Sort the array of datarefs to make building the interleaving chains
   linear.  Don't modify the original vector's order, it is needed for
   determining what dependencies are reversed.  */
vec<dr_vec_info *> datarefs_copy;
datarefs_copy.create (datarefs.length ());
for (unsigned i = 0; i < datarefs.length (); i++)
  {
    dr_vec_info *dr_info = vinfo->lookup_dr (datarefs[i]);
    /* If the caller computed DR grouping use that, otherwise group by
basic blocks.  */
    if (dataref_groups)
dr_info->group = (*dataref_groups)[i];
    else
dr_info->group = gimple_bb (DR_STMT (datarefs[i])(datarefs[i])->stmt)->index;
    datarefs_copy.quick_push (dr_info);
  }
datarefs_copy.qsort (dr_group_sort_cmp)qsort (dr_group_sort_cmp);
hash_set<stmt_vec_info> to_fixup;

/* Build the interleaving chains.  */
for (i = 0; i < datarefs_copy.length () - 1;)
  {
    dr_vec_info *dr_info_a = datarefs_copy[i];
    data_reference_p dra = dr_info_a->dr;
    int dra_group_id = dr_info_a->group;
    stmt_vec_info stmtinfo_a = dr_info_a->stmt;
    stmt_vec_info lastinfo = NULLnullptr;
    if (!STMT_VINFO_VECTORIZABLE (stmtinfo_a)(stmtinfo_a)->vectorizable
 || STMT_VINFO_GATHER_SCATTER_P (stmtinfo_a)(stmtinfo_a)->gather_scatter_p)
{
 ++i;
 continue;
}
    for (i = i + 1; i < datarefs_copy.length (); ++i)
{
 dr_vec_info *dr_info_b = datarefs_copy[i];
 data_reference_p drb = dr_info_b->dr;
 int drb_group_id = dr_info_b->group;
 stmt_vec_info stmtinfo_b = dr_info_b->stmt;
 if (!STMT_VINFO_VECTORIZABLE (stmtinfo_b)(stmtinfo_b)->vectorizable
     || STMT_VINFO_GATHER_SCATTER_P (stmtinfo_b)(stmtinfo_b)->gather_scatter_p)
   break;

 /* ???  Imperfect sorting (non-compatible types, non-modulo
    accesses, same accesses) can lead to a group to be artificially
    split here as we don't just skip over those.  If it really
    matters we can push those to a worklist and re-iterate
    over them.  The we can just skip ahead to the next DR here.  */

 /* DRs in a different DR group should not be put into the same
    interleaving group.  */
 if (dra_group_id != drb_group_id)
   break;

 /* Check that the data-refs have same first location (except init)
    and they are both either store or load (not load and store,
    not masked loads or stores).  */
 if (DR_IS_READ (dra)(dra)->is_read != DR_IS_READ (drb)(drb)->is_read
     || data_ref_compare_tree (DR_BASE_ADDRESS (dra)(dra)->innermost.base_address,
			DR_BASE_ADDRESS (drb)(drb)->innermost.base_address) != 0
     || data_ref_compare_tree (DR_OFFSET (dra)(dra)->innermost.offset, DR_OFFSET (drb)(drb)->innermost.offset) != 0
     || !can_group_stmts_p (stmtinfo_a, stmtinfo_b, true))
   break;

 /* Check that the data-refs have the same constant size.  */
 tree sza = TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (dra)))((tree_class_check ((((contains_struct_check (((dra)->ref)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3157, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3157, __FUNCTION__))->type_common.size_unit);
 tree szb = TYPE_SIZE_UNIT (TREE_TYPE (DR_REF (drb)))((tree_class_check ((((contains_struct_check (((drb)->ref)
, (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3158, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3158, __FUNCTION__))->type_common.size_unit);
 if (!tree_fits_uhwi_p (sza)
     || !tree_fits_uhwi_p (szb)
     || !tree_int_cst_equal (sza, szb))
   break;

 /* Check that the data-refs have the same step.  */
 if (data_ref_compare_tree (DR_STEP (dra)(dra)->innermost.step, DR_STEP (drb)(drb)->innermost.step) != 0)
   break;

 /* Check the types are compatible.
    ???  We don't distinguish this during sorting.  */
 if (!types_compatible_p (TREE_TYPE (DR_REF (dra))((contains_struct_check (((dra)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3170, __FUNCTION__))->typed.type),
		   TREE_TYPE (DR_REF (drb))((contains_struct_check (((drb)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3171, __FUNCTION__))->typed.type)))
   break;

 /* Check that the DR_INITs are compile-time constants.  */
 if (!tree_fits_shwi_p (DR_INIT (dra)(dra)->innermost.init)
     || !tree_fits_shwi_p (DR_INIT (drb)(drb)->innermost.init))
   break;

 /* Different .GOMP_SIMD_LANE calls still give the same lane,
    just hold extra information.  */
 if (STMT_VINFO_SIMD_LANE_ACCESS_P (stmtinfo_a)(stmtinfo_a)->simd_lane_access_p
     && STMT_VINFO_SIMD_LANE_ACCESS_P (stmtinfo_b)(stmtinfo_b)->simd_lane_access_p
     && data_ref_compare_tree (DR_INIT (dra)(dra)->innermost.init, DR_INIT (drb)(drb)->innermost.init) == 0)
   break;

 /* Sorting has ensured that DR_INIT (dra) <= DR_INIT (drb).  */
 HOST_WIDE_INTlong init_a = TREE_INT_CST_LOW (DR_INIT (dra))((unsigned long) (*tree_int_cst_elt_check (((dra)->innermost
.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3187, __FUNCTION__)));
 HOST_WIDE_INTlong init_b = TREE_INT_CST_LOW (DR_INIT (drb))((unsigned long) (*tree_int_cst_elt_check (((drb)->innermost
.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3188, __FUNCTION__)));
 HOST_WIDE_INTlong init_prev
   = TREE_INT_CST_LOW (DR_INIT (datarefs_copy[i-1]->dr))((unsigned long) (*tree_int_cst_elt_check (((datarefs_copy[i-
1]->dr)->innermost.init), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3190, __FUNCTION__)));
 gcc_assert (init_a <= init_b((void)(!(init_a <= init_b && init_a <= init_prev
 && init_prev <= init_b) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3193, __FUNCTION__), 0 : 0))
      && init_a <= init_prev((void)(!(init_a <= init_b && init_a <= init_prev
 && init_prev <= init_b) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3193, __FUNCTION__), 0 : 0))
      && init_prev <= init_b)((void)(!(init_a <= init_b && init_a <= init_prev
 && init_prev <= init_b) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3193, __FUNCTION__), 0 : 0));

 /* Do not place the same access in the interleaving chain twice.  */
 if (init_b == init_prev)
   {
     gcc_assert (gimple_uid (DR_STMT (datarefs_copy[i-1]->dr))((void)(!(gimple_uid ((datarefs_copy[i-1]->dr)->stmt) <
 gimple_uid ((drb)->stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3199, __FUNCTION__), 0 : 0))
	  < gimple_uid (DR_STMT (drb)))((void)(!(gimple_uid ((datarefs_copy[i-1]->dr)->stmt) <
 gimple_uid ((drb)->stmt)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3199, __FUNCTION__), 0 : 0));
     /* Simply link in duplicates and fix up the chain below.  */
   }
 else
   {
     /* If init_b == init_a + the size of the type * k, we have an
 interleaving, and DRA is accessed before DRB.  */
     unsigned HOST_WIDE_INTlong type_size_a = tree_to_uhwi (sza);
     if (type_size_a == 0
  || (((unsigned HOST_WIDE_INTlong)init_b - init_a)
      % type_size_a != 0))
break;

     /* If we have a store, the accesses are adjacent.  This splits
 groups into chunks we support (we don't support vectorization
 of stores with gaps).  */
     if (!DR_IS_READ (dra)(dra)->is_read
  && (((unsigned HOST_WIDE_INTlong)init_b - init_prev)
      != type_size_a))
break;

     /* If the step (if not zero or non-constant) is smaller than the
 difference between data-refs' inits this splits groups into
 suitable sizes.  */
     if (tree_fits_shwi_p (DR_STEP (dra)(dra)->innermost.step))
{
  unsigned HOST_WIDE_INTlong step
    = absu_hwi (tree_to_shwi (DR_STEP (dra)(dra)->innermost.step));
  if (step != 0
      && step <= ((unsigned HOST_WIDE_INTlong)init_b - init_a))
    break;
}
   }

 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     DR_IS_READ (dra)(dra)->is_read
	     ? "Detected interleaving load %T and %T\n"
	     : "Detected interleaving store %T and %T\n",
	     DR_REF (dra)(dra)->ref, DR_REF (drb)(drb)->ref);

 /* Link the found element into the group list.  */
 if (!DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3241, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
))
   {
     DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3243, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
) = stmtinfo_a;
     lastinfo = stmtinfo_a;
   }
 DR_GROUP_FIRST_ELEMENT (stmtinfo_b)(((void)(!((stmtinfo_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3246, __FUNCTION__), 0 : 0)), (stmtinfo_b)->first_element
) = stmtinfo_a;
 DR_GROUP_NEXT_ELEMENT (lastinfo)(((void)(!((lastinfo)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3247, __FUNCTION__), 0 : 0)), (lastinfo)->next_element) = stmtinfo_b;
 lastinfo = stmtinfo_b;

 STMT_VINFO_SLP_VECT_ONLY (stmtinfo_a)(stmtinfo_a)->slp_vect_only_p
   = !can_group_stmts_p (stmtinfo_a, stmtinfo_b, false);

 if (dump_enabled_p () && STMT_VINFO_SLP_VECT_ONLY (stmtinfo_a)(stmtinfo_a)->slp_vect_only_p)
   dump_printf_loc (MSG_NOTE, vect_location,
	     "Load suitable for SLP vectorization only.\n");

 if (init_b == init_prev
     && !to_fixup.add (DR_GROUP_FIRST_ELEMENT (stmtinfo_a)(((void)(!((stmtinfo_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3258, __FUNCTION__), 0 : 0)), (stmtinfo_a)->first_element
))
     && dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "Queuing group with duplicate access for fixup\n");
}
  }

/* Fixup groups with duplicate entries by splitting it.  */
while (1)
  {
    hash_set<stmt_vec_info>::iterator it = to_fixup.begin ();
    if (!(it != to_fixup.end ()))
break;
    stmt_vec_info grp = *it;
    to_fixup.remove (grp);

    /* Find the earliest duplicate group member.  */
    unsigned first_duplicate = -1u;
    stmt_vec_info next, g = grp;
    while ((next = DR_GROUP_NEXT_ELEMENT (g)(((void)(!((g)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3277, __FUNCTION__), 0 : 0)), (g)->next_element)))
{
 if (tree_int_cst_equal (DR_INIT (STMT_VINFO_DR_INFO (next)->dr)((((void)(!((next)->dr_aux.stmt == (next)) ? fancy_abort (
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3279, __FUNCTION__), 0 : 0)), &(next)->dr_aux)->dr
)->innermost.init,
		  DR_INIT (STMT_VINFO_DR_INFO (g)->dr)((((void)(!((g)->dr_aux.stmt == (g)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3280, __FUNCTION__), 0 : 0)), &(g)->dr_aux)->dr)->
innermost.init)
     && gimple_uid (STMT_VINFO_STMT (next)(next)->stmt) < first_duplicate)
   first_duplicate = gimple_uid (STMT_VINFO_STMT (next)(next)->stmt);
 g = next;
}
    if (first_duplicate == -1U)
continue;

    /* Then move all stmts after the first duplicate to a new group.
       Note this is a heuristic but one with the property that *it
is fixed up completely.  */
    g = grp;
    stmt_vec_info newgroup = NULLnullptr, ng = grp;
    while ((next = DR_GROUP_NEXT_ELEMENT (g)(((void)(!((g)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3293, __FUNCTION__), 0 : 0)), (g)->next_element)))
{
 if (gimple_uid (STMT_VINFO_STMT (next)(next)->stmt) >= first_duplicate)
   {
     DR_GROUP_NEXT_ELEMENT (g)(((void)(!((g)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3297, __FUNCTION__), 0 : 0)), (g)->next_element) = DR_GROUP_NEXT_ELEMENT (next)(((void)(!((next)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3297, __FUNCTION__), 0 : 0)), (next)->next_element);
     if (!newgroup)
newgroup = next;
     else
DR_GROUP_NEXT_ELEMENT (ng)(((void)(!((ng)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3301, __FUNCTION__), 0 : 0)), (ng)->next_element) = next;
     ng = next;
     DR_GROUP_FIRST_ELEMENT (ng)(((void)(!((ng)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3303, __FUNCTION__), 0 : 0)), (ng)->first_element) = newgroup;
   }
 else
   g = DR_GROUP_NEXT_ELEMENT (g)(((void)(!((g)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3306, __FUNCTION__), 0 : 0)), (g)->next_element);
}
    DR_GROUP_NEXT_ELEMENT (ng)(((void)(!((ng)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3308, __FUNCTION__), 0 : 0)), (ng)->next_element) = NULLnullptr;

    /* Fixup the new group which still may contain duplicates.  */
    to_fixup.add (newgroup);
  }

dr_vec_info *dr_info;
FOR_EACH_VEC_ELT (datarefs_copy, i, dr_info)for (i = 0; (datarefs_copy).iterate ((i), &(dr_info)); ++
(i))
  {
    if (STMT_VINFO_VECTORIZABLE (dr_info->stmt)(dr_info->stmt)->vectorizable
 && !vect_analyze_data_ref_access (vinfo, dr_info))
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
	     "not vectorized: complicated access pattern.\n");

 if (is_a <bb_vec_info> (vinfo))
   {
     /* Mark the statement as not vectorizable.  */
     STMT_VINFO_VECTORIZABLE (dr_info->stmt)(dr_info->stmt)->vectorizable = false;
     continue;
   }
 else
   {
     datarefs_copy.release ();
     return opt_result::failure_at (dr_info->stmt->stmt,
			     "not vectorized:"
			     " complicated access pattern.\n");
   }
}
  }

datarefs_copy.release ();
return opt_result::success ();
3342}

3344/* Function vect_vfa_segment_size.

 Input:
   DR_INFO: The data reference.
   LENGTH_FACTOR: segment length to consider.

 Return a value suitable for the dr_with_seg_len::seg_len field.
 This is the "distance travelled" by the pointer from the first
 iteration in the segment to the last.  Note that it does not include
 the size of the access; in effect it only describes the first byte.  */

3355static tree
3356vect_vfa_segment_size (dr_vec_info *dr_info, tree length_factor)
3357{
length_factor = size_binop (MINUS_EXPR,size_binop_loc (((location_t) 0), MINUS_EXPR, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], length_factor
), global_trees[TI_SIZE_ONE])
	      fold_convert (sizetype, length_factor),size_binop_loc (((location_t) 0), MINUS_EXPR, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], length_factor
), global_trees[TI_SIZE_ONE])
	      size_one_node)size_binop_loc (((location_t) 0), MINUS_EXPR, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], length_factor
), global_trees[TI_SIZE_ONE]);
return size_binop (MULT_EXPR, fold_convert (sizetype, DR_STEP (dr_info->dr)),size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], (dr_info
->dr)->innermost.step), length_factor)
     length_factor)size_binop_loc (((location_t) 0), MULT_EXPR, fold_convert_loc
 (((location_t) 0), sizetype_tab[(int) stk_sizetype], (dr_info
->dr)->innermost.step), length_factor);
3363}

3365/* Return a value that, when added to abs (vect_vfa_segment_size (DR_INFO)),
 gives the worst-case number of bytes covered by the segment.  */

3368static unsigned HOST_WIDE_INTlong
3369vect_vfa_access_size (vec_info *vinfo, dr_vec_info *dr_info)
3370{
stmt_vec_info stmt_vinfo = dr_info->stmt;
tree ref_type = TREE_TYPE (DR_REF (dr_info->dr))((contains_struct_check (((dr_info->dr)->ref), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3372, __FUNCTION__))->typed.type);
unsigned HOST_WIDE_INTlong ref_size = tree_to_uhwi (TYPE_SIZE_UNIT (ref_type)((tree_class_check ((ref_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3373, __FUNCTION__))->type_common.size_unit));
unsigned HOST_WIDE_INTlong access_size = ref_size;
if (DR_GROUP_FIRST_ELEMENT (stmt_vinfo)(((void)(!((stmt_vinfo)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3375, __FUNCTION__), 0 : 0)), (stmt_vinfo)->first_element
))
  {
    gcc_assert (DR_GROUP_FIRST_ELEMENT (stmt_vinfo) == stmt_vinfo)((void)(!((((void)(!((stmt_vinfo)->dr_aux.dr) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3377, __FUNCTION__), 0 : 0)), (stmt_vinfo)->first_element
) == stmt_vinfo) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3377, __FUNCTION__), 0 : 0));
    access_size *= DR_GROUP_SIZE (stmt_vinfo)(((void)(!((stmt_vinfo)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3378, __FUNCTION__), 0 : 0)), (stmt_vinfo)->size) - DR_GROUP_GAP (stmt_vinfo)(((void)(!((stmt_vinfo)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3378, __FUNCTION__), 0 : 0)), (stmt_vinfo)->gap);
  }
tree vectype = STMT_VINFO_VECTYPE (stmt_vinfo)(stmt_vinfo)->vectype;
int misalignment;
if (STMT_VINFO_VEC_STMTS (stmt_vinfo)(stmt_vinfo)->vec_stmts.exists ()
    && ((misalignment = dr_misalignment (dr_info, vectype)), true)
    && (vect_supportable_dr_alignment (vinfo, dr_info, vectype, misalignment)
 == dr_explicit_realign_optimized))
  {
    /* We might access a full vector's worth.  */
    access_size += tree_to_uhwi (TYPE_SIZE_UNIT (vectype)((tree_class_check ((vectype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3388, __FUNCTION__))->type_common.size_unit)) - ref_size;
  }
return access_size;
3391}

3393/* Get the minimum alignment for all the scalar accesses that DR_INFO
 describes.  */

3396static unsigned int
3397vect_vfa_align (dr_vec_info *dr_info)
3398{
return dr_alignment (dr_info->dr);
3400}

3402/* Function vect_no_alias_p.

 Given data references A and B with equal base and offset, see whether
 the alias relation can be decided at compilation time.  Return 1 if
 it can and the references alias, 0 if it can and the references do
 not alias, and -1 if we cannot decide at compile time.  SEGMENT_LENGTH_A,
 SEGMENT_LENGTH_B, ACCESS_SIZE_A and ACCESS_SIZE_B are the equivalent
 of dr_with_seg_len::{seg_len,access_size} for A and B.  */

3411static int
3412vect_compile_time_alias (dr_vec_info *a, dr_vec_info *b,
	 tree segment_length_a, tree segment_length_b,
	 unsigned HOST_WIDE_INTlong access_size_a,
	 unsigned HOST_WIDE_INTlong access_size_b)
3416{
poly_offset_int offset_a = wi::to_poly_offset (DR_INIT (a->dr)(a->dr)->innermost.init);
poly_offset_int offset_b = wi::to_poly_offset (DR_INIT (b->dr)(b->dr)->innermost.init);
poly_uint64 const_length_a;
poly_uint64 const_length_b;

/* For negative step, we need to adjust address range by TYPE_SIZE_UNIT
   bytes, e.g., int a[3] -> a[1] range is [a+4, a+16) instead of
   [a, a+12) */
if (tree_int_cst_compare (DR_STEP (a->dr)(a->dr)->innermost.step, size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0)
  {
    const_length_a = (-wi::to_poly_wide (segment_length_a)).force_uhwi ();
    offset_a -= const_length_a;
  }
else
  const_length_a = tree_to_poly_uint64 (segment_length_a);
if (tree_int_cst_compare (DR_STEP (b->dr)(b->dr)->innermost.step, size_zero_nodeglobal_trees[TI_SIZE_ZERO]) < 0)
  {
    const_length_b = (-wi::to_poly_wide (segment_length_b)).force_uhwi ();
    offset_b -= const_length_b;
  }
else
  const_length_b = tree_to_poly_uint64 (segment_length_b);

const_length_a += access_size_a;
const_length_b += access_size_b;

if (ranges_known_overlap_p (offset_a, const_length_a,
	      offset_b, const_length_b))
  return 1;

if (!ranges_maybe_overlap_p (offset_a, const_length_a,
	       offset_b, const_length_b))
  return 0;

return -1;
3452}

3454/* Return true if the minimum nonzero dependence distance for loop LOOP_DEPTH
 in DDR is >= VF.  */

3457static bool
3458dependence_distance_ge_vf (data_dependence_relation *ddr,
	   unsigned int loop_depth, poly_uint64 vf)
3460{
if (DDR_ARE_DEPENDENT (ddr)(ddr)->are_dependent != NULL_TREE(tree) nullptr
    || DDR_NUM_DIST_VECTS (ddr)(((ddr)->dist_vects).length ()) == 0)
  return false;

/* If the dependence is exact, we should have limited the VF instead.  */
gcc_checking_assert (DDR_COULD_BE_INDEPENDENT_P (ddr))((void)(!((ddr)->could_be_independent_p) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3466, __FUNCTION__), 0 : 0));

unsigned int i;
lambda_vector dist_v;
FOR_EACH_VEC_ELT (DDR_DIST_VECTS (ddr), i, dist_v)for (i = 0; (((ddr)->dist_vects)).iterate ((i), &(dist_v
)); ++(i))
  {
    HOST_WIDE_INTlong dist = dist_v[loop_depth];
    if (dist != 0
 && !(dist > 0 && DDR_REVERSED_P (ddr)(ddr)->reversed_p)
 && maybe_lt ((unsigned HOST_WIDE_INTlong) abs_hwi (dist), vf))
return false;
  }

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
     "dependence distance between %T and %T is >= VF\n",
     DR_REF (DDR_A (ddr))((ddr)->a)->ref, DR_REF (DDR_B (ddr))((ddr)->b)->ref);

return true;
3485}

3487/* Dump LOWER_BOUND using flags DUMP_KIND.  Dumps are known to be enabled.  */

3489static void
3490dump_lower_bound (dump_flags_t dump_kind, const vec_lower_bound &lower_bound)
3491{
dump_printf (dump_kind, "%s (%T) >= ",
      lower_bound.unsigned_p ? "unsigned" : "abs",
      lower_bound.expr);
dump_dec (dump_kind, lower_bound.min_value);
3496}

3498/* Record that the vectorized loop requires the vec_lower_bound described
 by EXPR, UNSIGNED_P and MIN_VALUE.  */

3501static void
3502vect_check_lower_bound (loop_vec_info loop_vinfo, tree expr, bool unsigned_p,
	poly_uint64 min_value)
3504{
vec<vec_lower_bound> &lower_bounds
  = LOOP_VINFO_LOWER_BOUNDS (loop_vinfo)(loop_vinfo)->lower_bounds;
for (unsigned int i = 0; i < lower_bounds.length (); ++i)
  if (operand_equal_p (lower_bounds[i].expr, expr, 0))
    {
unsigned_p &= lower_bounds[i].unsigned_p;
min_value = upper_bound (lower_bounds[i].min_value, min_value);
if (lower_bounds[i].unsigned_p != unsigned_p
   || maybe_lt (lower_bounds[i].min_value, min_value))
 {
   lower_bounds[i].unsigned_p = unsigned_p;
   lower_bounds[i].min_value = min_value;
   if (dump_enabled_p ())
     {
dump_printf_loc (MSG_NOTE, vect_location,
		 "updating run-time check to ");
dump_lower_bound (MSG_NOTE, lower_bounds[i]);
dump_printf (MSG_NOTE, "\n");
     }
 }
return;
    }

vec_lower_bound lower_bound (expr, unsigned_p, min_value);
if (dump_enabled_p ())
  {
    dump_printf_loc (MSG_NOTE, vect_location, "need a run-time check that ");
    dump_lower_bound (MSG_NOTE, lower_bound);
    dump_printf (MSG_NOTE, "\n");
  }
LOOP_VINFO_LOWER_BOUNDS (loop_vinfo)(loop_vinfo)->lower_bounds.safe_push (lower_bound);
3536}

3538/* Return true if it's unlikely that the step of the vectorized form of DR_INFO
 will span fewer than GAP bytes.  */

3541static bool
3542vect_small_gap_p (loop_vec_info loop_vinfo, dr_vec_info *dr_info,
  poly_int64 gap)
3544{
stmt_vec_info stmt_info = dr_info->stmt;
HOST_WIDE_INTlong count
  = estimated_poly_value (LOOP_VINFO_VECT_FACTOR (loop_vinfo)(loop_vinfo)->vectorization_factor);
if (DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3548, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))
  count *= DR_GROUP_SIZE (DR_GROUP_FIRST_ELEMENT (stmt_info))(((void)(!(((((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3549, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3549, __FUNCTION__), 0 : 0)), ((((void)(!((stmt_info)->dr_aux
.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3549, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
))->size);
return (estimated_poly_value (gap)
 <= count * vect_get_scalar_dr_size (dr_info));
3552}

3554/* Return true if we know that there is no alias between DR_INFO_A and
 DR_INFO_B when abs (DR_STEP (DR_INFO_A->dr)) >= N for some N.
 When returning true, set *LOWER_BOUND_OUT to this N.  */

3558static bool
3559vectorizable_with_step_bound_p (dr_vec_info *dr_info_a, dr_vec_info *dr_info_b,
		poly_uint64 *lower_bound_out)
3561{
/* Check that there is a constant gap of known sign between DR_A
   and DR_B.  */
data_reference *dr_a = dr_info_a->dr;
data_reference *dr_b = dr_info_b->dr;
poly_int64 init_a, init_b;
if (!operand_equal_p (DR_BASE_ADDRESS (dr_a)(dr_a)->innermost.base_address, DR_BASE_ADDRESS (dr_b)(dr_b)->innermost.base_address, 0)
    || !operand_equal_p (DR_OFFSET (dr_a)(dr_a)->innermost.offset, DR_OFFSET (dr_b)(dr_b)->innermost.offset, 0)
    || !operand_equal_p (DR_STEP (dr_a)(dr_a)->innermost.step, DR_STEP (dr_b)(dr_b)->innermost.step, 0)
    || !poly_int_tree_p (DR_INIT (dr_a)(dr_a)->innermost.init, &init_a)
    || !poly_int_tree_p (DR_INIT (dr_b)(dr_b)->innermost.init, &init_b)
    || !ordered_p (init_a, init_b))
  return false;

/* Sort DR_A and DR_B by the address they access.  */
if (maybe_lt (init_b, init_a))
  {
    std::swap (init_a, init_b);
    std::swap (dr_info_a, dr_info_b);
    std::swap (dr_a, dr_b);
  }

/* If the two accesses could be dependent within a scalar iteration,
   make sure that we'd retain their order.  */
if (maybe_gt (init_a + vect_get_scalar_dr_size (dr_info_a), init_b)maybe_lt (init_b, init_a + vect_get_scalar_dr_size (dr_info_a
))
    && !vect_preserves_scalar_order_p (dr_info_a, dr_info_b))
  return false;

/* There is no alias if abs (DR_STEP) is greater than or equal to
   the bytes spanned by the combination of the two accesses.  */
*lower_bound_out = init_b + vect_get_scalar_dr_size (dr_info_b) - init_a;
return true;
3593}

3595/* Function vect_prune_runtime_alias_test_list.

 Prune a list of ddrs to be tested at run-time by versioning for alias.
 Merge several alias checks into one if possible.
 Return FALSE if resulting list of ddrs is longer then allowed by
 PARAM_VECT_MAX_VERSION_FOR_ALIAS_CHECKS, otherwise return TRUE.  */

3602opt_result
3603vect_prune_runtime_alias_test_list (loop_vec_info loop_vinfo)
3604{
typedef pair_hash <tree_operand_hash, tree_operand_hash> tree_pair_hash;
hash_set <tree_pair_hash> compared_objects;

const vec<ddr_p> &may_alias_ddrs = LOOP_VINFO_MAY_ALIAS_DDRS (loop_vinfo)(loop_vinfo)->may_alias_ddrs;
vec<dr_with_seg_len_pair_t> &comp_alias_ddrs
  = LOOP_VINFO_COMP_ALIAS_DDRS (loop_vinfo)(loop_vinfo)->comp_alias_ddrs;
const vec<vec_object_pair> &check_unequal_addrs
  = LOOP_VINFO_CHECK_UNEQUAL_ADDRS (loop_vinfo)(loop_vinfo)->check_unequal_addrs;
poly_uint64 vect_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo)(loop_vinfo)->vectorization_factor;
tree scalar_loop_iters = LOOP_VINFO_NITERS (loop_vinfo)(loop_vinfo)->num_iters;

ddr_p ddr;
unsigned int i;
tree length_factor;

DUMP_VECT_SCOPE ("vect_prune_runtime_alias_test_list")auto_dump_scope scope ("vect_prune_runtime_alias_test_list", vect_location
);

/* Step values are irrelevant for aliasing if the number of vector
   iterations is equal to the number of scalar iterations (which can
   happen for fully-SLP loops).  */
bool vf_one_p = known_eq (LOOP_VINFO_VECT_FACTOR (loop_vinfo), 1U)(!maybe_ne ((loop_vinfo)->vectorization_factor, 1U));

if (!vf_one_p)
  {
    /* Convert the checks for nonzero steps into bound tests.  */
    tree value;
    FOR_EACH_VEC_ELT (LOOP_VINFO_CHECK_NONZERO (loop_vinfo), i, value)for (i = 0; ((loop_vinfo)->check_nonzero).iterate ((i), &
(value)); ++(i))
vect_check_lower_bound (loop_vinfo, value, true, 1);
  }

if (may_alias_ddrs.is_empty ())
  return opt_result::success ();

comp_alias_ddrs.create (may_alias_ddrs.length ());

unsigned int loop_depth
  = index_in_loop_nest (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop->num,
	  LOOP_VINFO_LOOP_NEST (loop_vinfo)(loop_vinfo)->shared->loop_nest);

/* First, we collect all data ref pairs for aliasing checks.  */
FOR_EACH_VEC_ELT (may_alias_ddrs, i, ddr)for (i = 0; (may_alias_ddrs).iterate ((i), &(ddr)); ++(i)
)
  {
    poly_uint64 lower_bound;
    tree segment_length_a, segment_length_b;
    unsigned HOST_WIDE_INTlong access_size_a, access_size_b;
    unsigned int align_a, align_b;

    /* Ignore the alias if the VF we chose ended up being no greater
than the dependence distance.  */
    if (dependence_distance_ge_vf (ddr, loop_depth, vect_factor))
continue;

    if (DDR_OBJECT_A (ddr)(ddr)->object_a)
{
 vec_object_pair new_pair (DDR_OBJECT_A (ddr)(ddr)->object_a, DDR_OBJECT_B (ddr)(ddr)->object_b);
 if (!compared_objects.add (new_pair))
   {
     if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
		 "checking that %T and %T"
		 " have different addresses\n",
		 new_pair.first, new_pair.second);
     LOOP_VINFO_CHECK_UNEQUAL_ADDRS (loop_vinfo)(loop_vinfo)->check_unequal_addrs.safe_push (new_pair);
   }
 continue;
}

    dr_vec_info *dr_info_a = loop_vinfo->lookup_dr (DDR_A (ddr)(ddr)->a);
    stmt_vec_info stmt_info_a = dr_info_a->stmt;

    dr_vec_info *dr_info_b = loop_vinfo->lookup_dr (DDR_B (ddr)(ddr)->b);
    stmt_vec_info stmt_info_b = dr_info_b->stmt;

    bool preserves_scalar_order_p
= vect_preserves_scalar_order_p (dr_info_a, dr_info_b);
    bool ignore_step_p
 = (vf_one_p
    && (preserves_scalar_order_p
 || operand_equal_p (DR_STEP (dr_info_a->dr)(dr_info_a->dr)->innermost.step,
		     DR_STEP (dr_info_b->dr)(dr_info_b->dr)->innermost.step)));

    /* Skip the pair if inter-iteration dependencies are irrelevant
and intra-iteration dependencies are guaranteed to be honored.  */
    if (ignore_step_p
 && (preserves_scalar_order_p
     || vectorizable_with_step_bound_p (dr_info_a, dr_info_b,
				 &lower_bound)))
{
 if (dump_enabled_p ())
   dump_printf_loc (MSG_NOTE, vect_location,
	     "no need for alias check between "
	     "%T and %T when VF is 1\n",
	     DR_REF (dr_info_a->dr)(dr_info_a->dr)->ref, DR_REF (dr_info_b->dr)(dr_info_b->dr)->ref);
 continue;
}

    /* See whether we can handle the alias using a bounds check on
the step, and whether that's likely to be the best approach.
(It might not be, for example, if the minimum step is much larger
than the number of bytes handled by one vector iteration.)  */
    if (!ignore_step_p
 && TREE_CODE (DR_STEP (dr_info_a->dr))((enum tree_code) ((dr_info_a->dr)->innermost.step)->
base.code) != INTEGER_CST
 && vectorizable_with_step_bound_p (dr_info_a, dr_info_b,
			     &lower_bound)
 && (vect_small_gap_p (loop_vinfo, dr_info_a, lower_bound)
     || vect_small_gap_p (loop_vinfo, dr_info_b, lower_bound)))
{
 bool unsigned_p = dr_known_forward_stride_p (dr_info_a->dr);
 if (dump_enabled_p ())
   {
     dump_printf_loc (MSG_NOTE, vect_location, "no alias between "
	       "%T and %T when the step %T is outside ",
	       DR_REF (dr_info_a->dr)(dr_info_a->dr)->ref,
	       DR_REF (dr_info_b->dr)(dr_info_b->dr)->ref,
	       DR_STEP (dr_info_a->dr)(dr_info_a->dr)->innermost.step);
     if (unsigned_p)
dump_printf (MSG_NOTE, "[0");
     else
{
  dump_printf (MSG_NOTE, "(");
  dump_dec (MSG_NOTE, poly_int64 (-lower_bound));
}
     dump_printf (MSG_NOTE, ", ");
     dump_dec (MSG_NOTE, lower_bound);
     dump_printf (MSG_NOTE, ")\n");
   }
 vect_check_lower_bound (loop_vinfo, DR_STEP (dr_info_a->dr)(dr_info_a->dr)->innermost.step,
		  unsigned_p, lower_bound);
 continue;
}

    stmt_vec_info dr_group_first_a = DR_GROUP_FIRST_ELEMENT (stmt_info_a)(((void)(!((stmt_info_a)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3736, __FUNCTION__), 0 : 0)), (stmt_info_a)->first_element
);
    if (dr_group_first_a)
{
 stmt_info_a = dr_group_first_a;
 dr_info_a = STMT_VINFO_DR_INFO (stmt_info_a)(((void)(!((stmt_info_a)->dr_aux.stmt == (stmt_info_a)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3740, __FUNCTION__), 0 : 0)), &(stmt_info_a)->dr_aux
);
}

    stmt_vec_info dr_group_first_b = DR_GROUP_FIRST_ELEMENT (stmt_info_b)(((void)(!((stmt_info_b)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3743, __FUNCTION__), 0 : 0)), (stmt_info_b)->first_element
);
    if (dr_group_first_b)
{
 stmt_info_b = dr_group_first_b;
 dr_info_b = STMT_VINFO_DR_INFO (stmt_info_b)(((void)(!((stmt_info_b)->dr_aux.stmt == (stmt_info_b)) ? fancy_abort
 ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3747, __FUNCTION__), 0 : 0)), &(stmt_info_b)->dr_aux
);
}

    if (ignore_step_p)
{
 segment_length_a = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
 segment_length_b = size_zero_nodeglobal_trees[TI_SIZE_ZERO];
}
    else
{
 if (!operand_equal_p (DR_STEP (dr_info_a->dr)(dr_info_a->dr)->innermost.step,
		DR_STEP (dr_info_b->dr)(dr_info_b->dr)->innermost.step, 0))
   length_factor = scalar_loop_iters;
 else
   length_factor = size_int (vect_factor)size_int_kind (vect_factor, stk_sizetype);
 segment_length_a = vect_vfa_segment_size (dr_info_a, length_factor);
 segment_length_b = vect_vfa_segment_size (dr_info_b, length_factor);
}
    access_size_a = vect_vfa_access_size (loop_vinfo, dr_info_a);
    access_size_b = vect_vfa_access_size (loop_vinfo, dr_info_b);
    align_a = vect_vfa_align (dr_info_a);
    align_b = vect_vfa_align (dr_info_b);

    /* See whether the alias is known at compilation time.  */
    if (operand_equal_p (DR_BASE_ADDRESS (dr_info_a->dr)(dr_info_a->dr)->innermost.base_address,
	   DR_BASE_ADDRESS (dr_info_b->dr)(dr_info_b->dr)->innermost.base_address, 0)
 && operand_equal_p (DR_OFFSET (dr_info_a->dr)(dr_info_a->dr)->innermost.offset,
	      DR_OFFSET (dr_info_b->dr)(dr_info_b->dr)->innermost.offset, 0)
 && TREE_CODE (DR_STEP (dr_info_a->dr))((enum tree_code) ((dr_info_a->dr)->innermost.step)->
base.code) == INTEGER_CST
 && TREE_CODE (DR_STEP (dr_info_b->dr))((enum tree_code) ((dr_info_b->dr)->innermost.step)->
base.code) == INTEGER_CST
 && poly_int_tree_p (segment_length_a)
 && poly_int_tree_p (segment_length_b))
{
 int res = vect_compile_time_alias (dr_info_a, dr_info_b,
			     segment_length_a,
			     segment_length_b,
			     access_size_a,
			     access_size_b);
 if (res >= 0 && dump_enabled_p ())
   {
     dump_printf_loc (MSG_NOTE, vect_location,
	       "can tell at compile time that %T and %T",
	       DR_REF (dr_info_a->dr)(dr_info_a->dr)->ref, DR_REF (dr_info_b->dr)(dr_info_b->dr)->ref);
     if (res == 0)
dump_printf (MSG_NOTE, " do not alias\n");
     else
dump_printf (MSG_NOTE, " alias\n");
   }

 if (res == 0)
   continue;

 if (res == 1)
   return opt_result::failure_at (stmt_info_b->stmt,
			   "not vectorized:"
			   " compilation time alias: %G%G",
			   stmt_info_a->stmt,
			   stmt_info_b->stmt);
}

    dr_with_seg_len dr_a (dr_info_a->dr, segment_length_a,
	    access_size_a, align_a);
    dr_with_seg_len dr_b (dr_info_b->dr, segment_length_b,
	    access_size_b, align_b);
    /* Canonicalize the order to be the one that's needed for accurate
RAW, WAR and WAW flags, in cases where the data references are
well-ordered.  The order doesn't really matter otherwise,
but we might as well be consistent.  */
    if (get_later_stmt (stmt_info_a, stmt_info_b) == stmt_info_a)
std::swap (dr_a, dr_b);

    dr_with_seg_len_pair_t dr_with_seg_len_pair
(dr_a, dr_b, (preserves_scalar_order_p
      ? dr_with_seg_len_pair_t::WELL_ORDERED
      : dr_with_seg_len_pair_t::REORDERED));

    comp_alias_ddrs.safe_push (dr_with_seg_len_pair);
  }

prune_runtime_alias_test_list (&comp_alias_ddrs, vect_factor);

unsigned int count = (comp_alias_ddrs.length ()
	+ check_unequal_addrs.length ());

if (count
    && (loop_cost_model (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop)
 == VECT_COST_MODEL_VERY_CHEAP))
  return opt_result::failure_at
    (vect_location, "would need a runtime alias check\n");

if (dump_enabled_p ())
  dump_printf_loc (MSG_NOTE, vect_location,
     "improved number of alias checks from %d to %d\n",
     may_alias_ddrs.length (), count);
unsigned limit = param_vect_max_version_for_alias_checksglobal_options.x_param_vect_max_version_for_alias_checks;
if (loop_cost_model (LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop) == VECT_COST_MODEL_CHEAP)
  limit = param_vect_max_version_for_alias_checksglobal_options.x_param_vect_max_version_for_alias_checks * 6 / 10;
if (count > limit)
  return opt_result::failure_at
    (vect_location,
     "number of versioning for alias run-time tests exceeds %d "
     "(--param vect-max-version-for-alias-checks)\n", limit);

return opt_result::success ();
3851}

3853/* Check whether we can use an internal function for a gather load
 or scatter store.  READ_P is true for loads and false for stores.
 MASKED_P is true if the load or store is conditional.  MEMORY_TYPE is
 the type of the memory elements being loaded or stored.  OFFSET_TYPE
 is the type of the offset that is being applied to the invariant
 base address.  SCALE is the amount by which the offset should
 be multiplied *after* it has been converted to address width.

 Return true if the function is supported, storing the function id in
 *IFN_OUT and the vector type for the offset in *OFFSET_VECTYPE_OUT.  */

3864bool
3865vect_gather_scatter_fn_p (vec_info *vinfo, bool read_p, bool masked_p,
	  tree vectype, tree memory_type, tree offset_type,
	  int scale, internal_fn *ifn_out,
	  tree *offset_vectype_out)
3869{
unsigned int memory_bits = tree_to_uhwi (TYPE_SIZE (memory_type)((tree_class_check ((memory_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3870, __FUNCTION__))->type_common.size));
unsigned int element_bits = vector_element_bits (vectype);
if (element_bits != memory_bits)
34
←
Assuming 'element_bits' is not equal to 'memory_bits'→
35
←
Taking true branch→
  /* For now the vector elements must be the same width as the
     memory elements.  */
  return false;
36
←
Returning without writing to '*offset_vectype_out'→

/* Work out which function we need.  */
internal_fn ifn, alt_ifn;
if (read_p)
  {
    ifn = masked_p ? IFN_MASK_GATHER_LOAD : IFN_GATHER_LOAD;
    alt_ifn = IFN_MASK_GATHER_LOAD;
  }
else
  {
    ifn = masked_p ? IFN_MASK_SCATTER_STORE : IFN_SCATTER_STORE;
    alt_ifn = IFN_MASK_SCATTER_STORE;
  }

for (;;)
  {
    tree offset_vectype = get_vectype_for_scalar_type (vinfo, offset_type);
    if (!offset_vectype)
return false;

    /* Test whether the target supports this combination.  */
    if (internal_gather_scatter_fn_supported_p (ifn, vectype, memory_type,
				  offset_vectype, scale))
{
 *ifn_out = ifn;
 *offset_vectype_out = offset_vectype;
 return true;
}
    else if (!masked_p
      && internal_gather_scatter_fn_supported_p (alt_ifn, vectype,
					  memory_type,
					  offset_vectype,
					  scale))
{
 *ifn_out = alt_ifn;
 *offset_vectype_out = offset_vectype;
 return true;
}

    if (TYPE_PRECISION (offset_type)((tree_class_check ((offset_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3915, __FUNCTION__))->type_common.precision) >= POINTER_SIZE(((global_options.x_ix86_isa_flags & (1UL << 58)) !=
 0) ? 32 : ((8) * (((global_options.x_ix86_isa_flags & (1UL
 << 1)) != 0) ? 8 : 4)))
 && TYPE_PRECISION (offset_type)((tree_class_check ((offset_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3916, __FUNCTION__))->type_common.precision) >= element_bits)
return false;

    offset_type = build_nonstandard_integer_type
(TYPE_PRECISION (offset_type)((tree_class_check ((offset_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3920, __FUNCTION__))->type_common.precision) * 2, TYPE_UNSIGNED (offset_type)((tree_class_check ((offset_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3920, __FUNCTION__))->base.u.bits.unsigned_flag));
  }
3922}

3924/* STMT_INFO is a call to an internal gather load or scatter store function.
 Describe the operation in INFO.  */

3927static void
3928vect_describe_gather_scatter_call (stmt_vec_info stmt_info,
		   gather_scatter_info *info)
3930{
gcall *call = as_a <gcall *> (stmt_info->stmt);
tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;
data_reference *dr = STMT_VINFO_DATA_REF (stmt_info)((stmt_info)->dr_aux.dr + 0);

info->ifn = gimple_call_internal_fn (call);
info->decl = NULL_TREE(tree) nullptr;
info->base = gimple_call_arg (call, 0);
info->offset = gimple_call_arg (call, 1);
info->offset_dt = vect_unknown_def_type;
info->offset_vectype = NULL_TREE(tree) nullptr;
info->scale = TREE_INT_CST_LOW (gimple_call_arg (call, 2))((unsigned long) (*tree_int_cst_elt_check ((gimple_call_arg (
call, 2)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3941, __FUNCTION__)));
info->element_type = TREE_TYPE (vectype)((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3942, __FUNCTION__))->typed.type);
info->memory_type = TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3943, __FUNCTION__))->typed.type);
3944}

3946/* Return true if a non-affine read or write in STMT_INFO is suitable for a
 gather load or scatter store.  Describe the operation in *INFO if so.  */

3949bool
3950vect_check_gather_scatter (stmt_vec_info stmt_info, loop_vec_info loop_vinfo,
	   gather_scatter_info *info)
3952{
HOST_WIDE_INTlong scale = 1;
poly_int64 pbitpos, pbitsize;
class loop *loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop;
struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info)((stmt_info)->dr_aux.dr + 0);
tree offtype = NULL_TREE(tree) nullptr;
tree decl = NULL_TREE(tree) nullptr, base, off;
tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype;
tree memory_type = TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3960, __FUNCTION__))->typed.type);
machine_mode pmode;
int punsignedp, reversep, pvolatilep = 0;
internal_fn ifn;
tree offset_vectype;
1
'offset_vectype' declared without an initial value→
bool masked_p = false;

/* See whether this is already a call to a gather/scatter internal function.
   If not, see whether it's a masked load or store.  */
gcall *call = dyn_cast <gcall *> (stmt_info->stmt);
2
←
Calling 'dyn_cast<gcall *, gimple>'→
5
←
Returning from 'dyn_cast<gcall *, gimple>'→
if (call5.1
'call' is null
1
'call' is null
 && gimple_call_internal_p (call))
  {
    ifn = gimple_call_internal_fn (call);
    if (internal_gather_scatter_fn_p (ifn))
{
 vect_describe_gather_scatter_call (stmt_info, info);
 return true;
}
    masked_p = (ifn == IFN_MASK_LOAD || ifn == IFN_MASK_STORE);
  }

/* True if we should aim to use internal functions rather than
   built-in functions.  */
bool use_ifn_p = (DR_IS_READ (dr)(dr)->is_read
6
←
Assuming field 'is_read' is false→
7
←
'?' condition is false→
    ? supports_vec_gather_load_p (TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3984, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (vectype) : (vectype)->type_common.mode))
    : supports_vec_scatter_store_p (TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3985, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
 (vectype) : (vectype)->type_common.mode)));
8
←
Assuming field 'code' is not equal to VECTOR_TYPE→
9
←
'?' condition is false→

base = DR_REF (dr)(dr)->ref;
/* For masked loads/stores, DR_REF (dr) is an artificial MEM_REF,
   see if we can use the def stmt of the address.  */
if (masked_p9.1
'masked_p' is false

9.1	'masked_p' is false

3991 && TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF 3992 && TREE_CODE (TREE_OPERAND (base, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3992, __FUNCTION__))))))->base.code) == SSA_NAME 3993 && integer_zerop (TREE_OPERAND (base, 1)(*((const_cast<tree*> (tree_operand_check ((base), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3993, __FUNCTION__)))))) 3994 && !expr_invariant_in_loop_p (loop, TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3994, __FUNCTION__))))))) 3995 { 3996 gimple *def_stmt = SSA_NAME_DEF_STMT (TREE_OPERAND (base, 0))(tree_check (((*((const_cast<tree*> (tree_operand_check
((base), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3996, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3996, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 3997 if (is_gimple_assign (def_stmt) 3998 && gimple_assign_rhs_code (def_stmt) == ADDR_EXPR) 3999 base = TREE_OPERAND (gimple_assign_rhs1 (def_stmt), 0)(*((const_cast<tree*> (tree_operand_check ((gimple_assign_rhs1
(def_stmt)), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 3999, __FUNCTION__))))); 4000 } 4001 4002 /* The gather and scatter builtins need address of the form 4003 loop_invariant + vector * {1, 2, 4, 8} 4004 or 4005 loop_invariant + sign_extend (vector) * { 1, 2, 4, 8 }. 4006 Unfortunately DR_BASE_ADDRESS/DR_OFFSET can be a mixture 4007 of loop invariants/SSA_NAMEs defined in the loop, with casts, 4008 multiplications and additions in it. To get a vector, we need 4009 a single SSA_NAME that will be defined in the loop and will 4010 contain everything that is not loop invariant and that can be 4011 vectorized. The following code attempts to find such a preexistng 4012 SSA_NAME OFF and put the loop invariants into a tree BASE 4013 that can be gimplified before the loop. */ 4014 base = get_inner_reference (base, &pbitsize, &pbitpos, &off, &pmode, 4015 &punsignedp, &reversep, &pvolatilep); 4016 if (reversep)

←

Assuming 'reversep' is 0

→

←

Taking false branch

→

4017 return false; 4018 4019 /* PR 107346. Packed structs can have fields at offsets that are not 4020 multiples of BITS_PER_UNIT. Do not use gather/scatters in such cases. */ 4021 if (!multiple_p (pbitpos, BITS_PER_UNIT(8)))

←

Taking false branch

→

4022 return false; 4023 4024 poly_int64 pbytepos = exact_div (pbitpos, BITS_PER_UNIT(8)); 4025 4026 if (TREE_CODE (base)((enum tree_code) (base)->base.code) == MEM_REF)

←

Assuming field 'code' is not equal to MEM_REF

→

←

Taking false branch

→

4027 { 4028 if (!integer_zerop (TREE_OPERAND (base, 1)(*((const_cast<tree*> (tree_operand_check ((base), (1),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4028, __FUNCTION__))))))) 4029 { 4030 if (off == NULL_TREE(tree) nullptr) 4031 off = wide_int_to_tree (sizetypesizetype_tab[(int) stk_sizetype], mem_ref_offset (base)); 4032 else 4033 off = size_binop (PLUS_EXPR, off,size_binop_loc (((location_t) 0), PLUS_EXPR, off, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], (*((const_cast
<tree*> (tree_operand_check ((base), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4034, __FUNCTION__))))))) 4034 fold_convert (sizetype, TREE_OPERAND (base, 1)))size_binop_loc (((location_t) 0), PLUS_EXPR, off, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], (*((const_cast
<tree*> (tree_operand_check ((base), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4034, __FUNCTION__))))))); 4035 } 4036 base = TREE_OPERAND (base, 0)(*((const_cast<tree*> (tree_operand_check ((base), (0),
"/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4036, __FUNCTION__))))); 4037 } 4038 else 4039 base = build_fold_addr_expr (base)build_fold_addr_expr_loc (((location_t) 0), (base)); 4040 4041 if (off == NULL_TREE(tree) nullptr)

←

Assuming the condition is false

→

←

Taking false branch

→

4042 off = size_zero_nodeglobal_trees[TI_SIZE_ZERO]; 4043 4044 /* If base is not loop invariant, either off is 0, then we start with just 4045 the constant offset in the loop invariant BASE and continue with base 4046 as OFF, otherwise give up. 4047 We could handle that case by gimplifying the addition of base + off 4048 into some SSA_NAME and use that as off, but for now punt. */ 4049 if (!expr_invariant_in_loop_p (loop, base))

←

Assuming the condition is false

→

←

Taking false branch

→

4050 { 4051 if (!integer_zerop (off)) 4052 return false; 4053 off = base; 4054 base = size_int (pbytepos)size_int_kind (pbytepos, stk_sizetype); 4055 } 4056 /* Otherwise put base + constant offset into the loop invariant BASE 4057 and continue with OFF. */ 4058 else 4059 { 4060 base = fold_convert (sizetype, base)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], base); 4061 base = size_binop (PLUS_EXPR, base, size_int (pbytepos))size_binop_loc (((location_t) 0), PLUS_EXPR, base, size_int_kind
(pbytepos, stk_sizetype)); 4062 } 4063 4064 /* OFF at this point may be either a SSA_NAME or some tree expression 4065 from get_inner_reference. Try to peel off loop invariants from it 4066 into BASE as long as possible. */ 4067 STRIP_NOPS (off)(off) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((off))))); 4068 while (offtype == NULL_TREE(tree) nullptr)

←

Loop condition is true. Entering loop body

→

4069 { 4070 enum tree_code code; 4071 tree op0, op1, add = NULL_TREE(tree) nullptr; 4072 4073 if (TREE_CODE (off)((enum tree_code) (off)->base.code) == SSA_NAME)

←

Assuming field 'code' is equal to SSA_NAME

→

←

Taking true branch

→

4074 { 4075 gimple *def_stmt = SSA_NAME_DEF_STMT (off)(tree_check ((off), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4075, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 4076 4077 if (expr_invariant_in_loop_p (loop, off))

←

Assuming the condition is false

→

←

Taking false branch

→

4078 return false; 4079 4080 if (gimple_code (def_stmt) != GIMPLE_ASSIGN)

←

Assuming the condition is true

→

←

Taking true branch

→

4081 break; 4082 4083 op0 = gimple_assign_rhs1 (def_stmt); 4084 code = gimple_assign_rhs_code (def_stmt); 4085 op1 = gimple_assign_rhs2 (def_stmt); 4086 } 4087 else 4088 { 4089 if (get_gimple_rhs_class (TREE_CODE (off)((enum tree_code) (off)->base.code)) == GIMPLE_TERNARY_RHS) 4090 return false; 4091 code = TREE_CODE (off)((enum tree_code) (off)->base.code); 4092 extract_ops_from_tree (off, &code, &op0, &op1); 4093 } 4094 switch (code) 4095 { 4096 case POINTER_PLUS_EXPR: 4097 case PLUS_EXPR: 4098 if (expr_invariant_in_loop_p (loop, op0)) 4099 { 4100 add = op0; 4101 off = op1; 4102 do_add: 4103 add = fold_convert (sizetype, add)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], add); 4104 if (scale != 1) 4105 add = size_binop (MULT_EXPR, add, size_int (scale))size_binop_loc (((location_t) 0), MULT_EXPR, add, size_int_kind
(scale, stk_sizetype)); 4106 base = size_binop (PLUS_EXPR, base, add)size_binop_loc (((location_t) 0), PLUS_EXPR, base, add); 4107 continue; 4108 } 4109 if (expr_invariant_in_loop_p (loop, op1)) 4110 { 4111 add = op1; 4112 off = op0; 4113 goto do_add; 4114 } 4115 break; 4116 case MINUS_EXPR: 4117 if (expr_invariant_in_loop_p (loop, op1)) 4118 { 4119 add = fold_convert (sizetype, op1)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], op1); 4120 add = size_binop (MINUS_EXPR, size_zero_node, add)size_binop_loc (((location_t) 0), MINUS_EXPR, global_trees[TI_SIZE_ZERO
], add); 4121 off = op0; 4122 goto do_add; 4123 } 4124 break; 4125 case MULT_EXPR: 4126 if (scale == 1 && tree_fits_shwi_p (op1)) 4127 { 4128 int new_scale = tree_to_shwi (op1); 4129 /* Only treat this as a scaling operation if the target 4130 supports it for at least some offset type. */ 4131 if (use_ifn_p 4132 && !vect_gather_scatter_fn_p (loop_vinfo, DR_IS_READ (dr)(dr)->is_read, 4133 masked_p, vectype, memory_type, 4134 signed_char_type_nodeinteger_types[itk_signed_char], 4135 new_scale, &ifn, 4136 &offset_vectype) 4137 && !vect_gather_scatter_fn_p (loop_vinfo, DR_IS_READ (dr)(dr)->is_read, 4138 masked_p, vectype, memory_type, 4139 unsigned_char_type_nodeinteger_types[itk_unsigned_char], 4140 new_scale, &ifn, 4141 &offset_vectype)) 4142 break; 4143 scale = new_scale; 4144 off = op0; 4145 continue; 4146 } 4147 break; 4148 case SSA_NAME: 4149 off = op0; 4150 continue; 4151 CASE_CONVERTcase NOP_EXPR: case CONVERT_EXPR: 4152 if (!POINTER_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4152, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4152, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) 4153 && !INTEGRAL_TYPE_P (TREE_TYPE (op0))(((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4153, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4153, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4153, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
)) 4154 break; 4155 4156 /* Don't include the conversion if the target is happy with 4157 the current offset type. */ 4158 if (use_ifn_p 4159 && TREE_CODE (off)((enum tree_code) (off)->base.code) == SSA_NAME 4160 && !POINTER_TYPE_P (TREE_TYPE (off))(((enum tree_code) (((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4160, __FUNCTION__))->typed.type))->base.code) == POINTER_TYPE
|| ((enum tree_code) (((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4160, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
) 4161 && vect_gather_scatter_fn_p (loop_vinfo, DR_IS_READ (dr)(dr)->is_read, 4162 masked_p, vectype, memory_type, 4163 TREE_TYPE (off)((contains_struct_check ((off), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4163, __FUNCTION__))->typed.type), scale, &ifn, 4164 &offset_vectype)) 4165 break; 4166 4167 if (TYPE_PRECISION (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4167, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4167, __FUNCTION__))->type_common.precision) 4168 == TYPE_PRECISION (TREE_TYPE (off))((tree_class_check ((((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4168, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4168, __FUNCTION__))->type_common.precision)) 4169 { 4170 off = op0; 4171 continue; 4172 } 4173 4174 /* Include the conversion if it is widening and we're using 4175 the IFN path or the target can handle the converted from 4176 offset or the current size is not already the same as the 4177 data vector element size. */ 4178 if ((TYPE_PRECISION (TREE_TYPE (op0))((tree_class_check ((((contains_struct_check ((op0), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4178, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4178, __FUNCTION__))->type_common.precision) 4179 < TYPE_PRECISION (TREE_TYPE (off))((tree_class_check ((((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4179, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4179, __FUNCTION__))->type_common.precision)) 4180 && (use_ifn_p 4181 || (DR_IS_READ (dr)(dr)->is_read 4182 ? (targetm.vectorize.builtin_gather 4183 && targetm.vectorize.builtin_gather (vectype, 4184 TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4184, __FUNCTION__))->typed.type), 4185 scale)) 4186 : (targetm.vectorize.builtin_scatter 4187 && targetm.vectorize.builtin_scatter (vectype, 4188 TREE_TYPE (op0)((contains_struct_check ((op0), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4188, __FUNCTION__))->typed.type), 4189 scale))) 4190 || !operand_equal_p (TYPE_SIZE (TREE_TYPE (off))((tree_class_check ((((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4190, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4190, __FUNCTION__))->type_common.size), 4191 TYPE_SIZE (TREE_TYPE (vectype))((tree_class_check ((((contains_struct_check ((vectype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4191, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4191, __FUNCTION__))->type_common.size), 0))) 4192 { 4193 off = op0; 4194 offtype = TREE_TYPE (off)((contains_struct_check ((off), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4194, __FUNCTION__))->typed.type); 4195 STRIP_NOPS (off)(off) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((off))))); 4196 continue; 4197 } 4198 break; 4199 default: 4200 break; 4201 } 4202 break; 4203 } 4204 4205 /* If at the end OFF still isn't a SSA_NAME or isn't 4206 defined in the loop, punt. */ 4207 if (TREE_CODE (off)((enum tree_code) (off)->base.code) != SSA_NAME

←

Execution continues on line 4207

→

←

Assuming field 'code' is equal to SSA_NAME

→

←

Taking false branch

→

4208 || expr_invariant_in_loop_p (loop, off))

←

Assuming the condition is false

→

4209 return false; 4210 4211 if (offtype == NULL_TREE(tree) nullptr)

←

Taking true branch

→

4212 offtype = TREE_TYPE (off)((contains_struct_check ((off), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4212, __FUNCTION__))->typed.type); 4213 4214 if (use_ifn_p)

←

Assuming 'use_ifn_p' is true

→

←

Taking true branch

→

4215 { 4216 if (!vect_gather_scatter_fn_p (loop_vinfo, DR_IS_READ (dr)(dr)->is_read, masked_p,

←

Calling 'vect_gather_scatter_fn_p'

→

←

Returning from 'vect_gather_scatter_fn_p'

→

←

Taking true branch

→

4217 vectype, memory_type, offtype, scale, 4218 &ifn, &offset_vectype)) 4219 ifn = IFN_LAST; 4220 decl = NULL_TREE(tree) nullptr; 4221 } 4222 else 4223 { 4224 if (DR_IS_READ (dr)(dr)->is_read) 4225 { 4226 if (targetm.vectorize.builtin_gather) 4227 decl = targetm.vectorize.builtin_gather (vectype, offtype, scale); 4228 } 4229 else 4230 { 4231 if (targetm.vectorize.builtin_scatter) 4232 decl = targetm.vectorize.builtin_scatter (vectype, offtype, scale); 4233 } 4234 ifn = IFN_LAST; 4235 /* The offset vector type will be read from DECL when needed. */ 4236 offset_vectype = NULL_TREE(tree) nullptr; 4237 } 4238 4239 info->ifn = ifn; 4240 info->decl = decl; 4241 info->base = base; 4242 info->offset = off; 4243 info->offset_dt = vect_unknown_def_type; 4244 info->offset_vectype = offset_vectype;

←

Assigned value is garbage or undefined

4245 info->scale = scale; 4246 info->element_type = TREE_TYPE (vectype)((contains_struct_check ((vectype), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4246, __FUNCTION__))->typed.type); 4247 info->memory_type = memory_type; 4248 return true; 4249} 4250 4251/* Find the data references in STMT, analyze them with respect to LOOP and 4252 append them to DATAREFS. Return false if datarefs in this stmt cannot 4253 be handled. */ 4254 4255opt_result 4256vect_find_stmt_data_reference (loop_p loop, gimple *stmt, 4257 vec<data_reference_p> *datarefs, 4258 vec<int> *dataref_groups, int group_id) 4259{ 4260 /* We can ignore clobbers for dataref analysis - they are removed during 4261 loop vectorization and BB vectorization checks dependences with a 4262 stmt walk. */ 4263 if (gimple_clobber_p (stmt)) 4264 return opt_result::success (); 4265 4266 if (gimple_has_volatile_ops (stmt)) 4267 return opt_result::failure_at (stmt, "not vectorized: volatile type: %G", 4268 stmt); 4269 4270 if (stmt_can_throw_internal (cfun(cfun + 0), stmt)) 4271 return opt_result::failure_at (stmt, 4272 "not vectorized:" 4273 " statement can throw an exception: %G", 4274 stmt); 4275 4276 auto_vec<data_reference_p, 2> refs; 4277 opt_result res = find_data_references_in_stmt (loop, stmt, &refs); 4278 if (!res) 4279 return res; 4280 4281 if (refs.is_empty ()) 4282 return opt_result::success (); 4283 4284 if (refs.length () > 1) 4285 { 4286 while (!refs.is_empty ()) 4287 free_data_ref (refs.pop ()); 4288 return opt_result::failure_at (stmt, 4289 "not vectorized: more than one " 4290 "data ref in stmt: %G", stmt); 4291 } 4292 4293 data_reference_p dr = refs.pop (); 4294 if (gcall *call = dyn_cast <gcall *> (stmt)) 4295 if (!gimple_call_internal_p (call) 4296 || (gimple_call_internal_fn (call) != IFN_MASK_LOAD 4297 && gimple_call_internal_fn (call) != IFN_MASK_STORE)) 4298 { 4299 free_data_ref (dr); 4300 return opt_result::failure_at (stmt, 4301 "not vectorized: dr in a call %G", stmt); 4302 } 4303 4304 if (TREE_CODE (DR_REF (dr))((enum tree_code) ((dr)->ref)->base.code) == COMPONENT_REF 4305 && DECL_BIT_FIELD (TREE_OPERAND (DR_REF (dr), 1))((tree_check (((*((const_cast<tree*> (tree_operand_check
(((dr)->ref), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4305, __FUNCTION__)))))), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4305, __FUNCTION__, (FIELD_DECL)))->decl_common.decl_flag_1
)) 4306 { 4307 free_data_ref (dr); 4308 return opt_result::failure_at (stmt, 4309 "not vectorized:" 4310 " statement is an unsupported" 4311 " bitfield access %G", stmt); 4312 } 4313 4314 if (DR_BASE_ADDRESS (dr)(dr)->innermost.base_address 4315 && TREE_CODE (DR_BASE_ADDRESS (dr))((enum tree_code) ((dr)->innermost.base_address)->base.
code) == INTEGER_CST) 4316 { 4317 free_data_ref (dr); 4318 return opt_result::failure_at (stmt, 4319 "not vectorized:" 4320 " base addr of dr is a constant\n"); 4321 } 4322 4323 /* Check whether this may be a SIMD lane access and adjust the 4324 DR to make it easier for us to handle it. */ 4325 if (loop 4326 && loop->simduid 4327 && (!DR_BASE_ADDRESS (dr)(dr)->innermost.base_address 4328 || !DR_OFFSET (dr)(dr)->innermost.offset 4329 || !DR_INIT (dr)(dr)->innermost.init 4330 || !DR_STEP (dr)(dr)->innermost.step)) 4331 { 4332 struct data_reference *newdr 4333 = create_data_ref (NULLnullptr, loop_containing_stmt (stmt), DR_REF (dr)(dr)->ref, stmt, 4334 DR_IS_READ (dr)(dr)->is_read, DR_IS_CONDITIONAL_IN_STMT (dr)(dr)->is_conditional_in_stmt); 4335 if (DR_BASE_ADDRESS (newdr)(newdr)->innermost.base_address 4336 && DR_OFFSET (newdr)(newdr)->innermost.offset 4337 && DR_INIT (newdr)(newdr)->innermost.init 4338 && DR_STEP (newdr)(newdr)->innermost.step 4339 && TREE_CODE (DR_INIT (newdr))((enum tree_code) ((newdr)->innermost.init)->base.code) == INTEGER_CST 4340 && integer_zerop (DR_STEP (newdr)(newdr)->innermost.step)) 4341 { 4342 tree base_address = DR_BASE_ADDRESS (newdr)(newdr)->innermost.base_address; 4343 tree off = DR_OFFSET (newdr)(newdr)->innermost.offset; 4344 tree step = ssize_int (1)size_int_kind (1, stk_ssizetype); 4345 if (integer_zerop (off) 4346 && TREE_CODE (base_address)((enum tree_code) (base_address)->base.code) == POINTER_PLUS_EXPR) 4347 { 4348 off = TREE_OPERAND (base_address, 1)(*((const_cast<tree*> (tree_operand_check ((base_address
), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4348, __FUNCTION__))))); 4349 base_address = TREE_OPERAND (base_address, 0)(*((const_cast<tree*> (tree_operand_check ((base_address
), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4349, __FUNCTION__))))); 4350 } 4351 STRIP_NOPS (off)(off) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((off))))); 4352 if (TREE_CODE (off)((enum tree_code) (off)->base.code) == MULT_EXPR 4353 && tree_fits_uhwi_p (TREE_OPERAND (off, 1)(*((const_cast<tree*> (tree_operand_check ((off), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4353, __FUNCTION__))))))) 4354 { 4355 step = TREE_OPERAND (off, 1)(*((const_cast<tree*> (tree_operand_check ((off), (1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4355, __FUNCTION__))))); 4356 off = TREE_OPERAND (off, 0)(*((const_cast<tree*> (tree_operand_check ((off), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4356, __FUNCTION__))))); 4357 STRIP_NOPS (off)(off) = tree_strip_nop_conversions ((const_cast<union tree_node
*> (((off))))); 4358 } 4359 if (CONVERT_EXPR_P (off)((((enum tree_code) (off)->base.code)) == NOP_EXPR || (((enum
tree_code) (off)->base.code)) == CONVERT_EXPR) 4360 && (TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (off, 0)))((tree_class_check ((((contains_struct_check (((*((const_cast
<tree*> (tree_operand_check ((off), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4360, __FUNCTION__)))))), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4360, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4360, __FUNCTION__))->type_common.precision) 4361 < TYPE_PRECISION (TREE_TYPE (off))((tree_class_check ((((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4361, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4361, __FUNCTION__))->type_common.precision))) 4362 off = TREE_OPERAND (off, 0)(*((const_cast<tree*> (tree_operand_check ((off), (0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4362, __FUNCTION__))))); 4363 if (TREE_CODE (off)((enum tree_code) (off)->base.code) == SSA_NAME) 4364 { 4365 gimple *def = SSA_NAME_DEF_STMT (off)(tree_check ((off), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4365, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 4366 /* Look through widening conversion. */ 4367 if (is_gimple_assign (def) 4368 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def))((gimple_assign_rhs_code (def)) == NOP_EXPR || (gimple_assign_rhs_code
(def)) == CONVERT_EXPR)) 4369 { 4370 tree rhs1 = gimple_assign_rhs1 (def); 4371 if (TREE_CODE (rhs1)((enum tree_code) (rhs1)->base.code) == SSA_NAME 4372 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1))(((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4372, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4372, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
|| ((enum tree_code) (((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4372, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
) 4373 && (TYPE_PRECISION (TREE_TYPE (off))((tree_class_check ((((contains_struct_check ((off), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4373, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4373, __FUNCTION__))->type_common.precision) 4374 > TYPE_PRECISION (TREE_TYPE (rhs1))((tree_class_check ((((contains_struct_check ((rhs1), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4374, __FUNCTION__))->typed.type)), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4374, __FUNCTION__))->type_common.precision))) 4375 def = SSA_NAME_DEF_STMT (rhs1)(tree_check ((rhs1), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4375, __FUNCTION__, (SSA_NAME)))->ssa_name.def_stmt; 4376 } 4377 if (is_gimple_call (def) 4378 && gimple_call_internal_p (def) 4379 && (gimple_call_internal_fn (def) == IFN_GOMP_SIMD_LANE)) 4380 { 4381 tree arg = gimple_call_arg (def, 0); 4382 tree reft = TREE_TYPE (DR_REF (newdr))((contains_struct_check (((newdr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4382, __FUNCTION__))->typed.type); 4383 gcc_assert (TREE_CODE (arg) == SSA_NAME)((void)(!(((enum tree_code) (arg)->base.code) == SSA_NAME)
? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4383, __FUNCTION__), 0 : 0)); 4384 arg = SSA_NAME_VAR (arg)((tree_check ((arg), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4384, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((arg)->ssa_name.var)->base
.code) == IDENTIFIER_NODE ? (tree) nullptr : (arg)->ssa_name
.var); 4385 if (arg == loop->simduid 4386 /* For now. */ 4387 && tree_int_cst_equal (TYPE_SIZE_UNIT (reft)((tree_class_check ((reft), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4387, __FUNCTION__))->type_common.size_unit), step)) 4388 { 4389 DR_BASE_ADDRESS (newdr)(newdr)->innermost.base_address = base_address; 4390 DR_OFFSET (newdr)(newdr)->innermost.offset = ssize_int (0)size_int_kind (0, stk_ssizetype); 4391 DR_STEP (newdr)(newdr)->innermost.step = step; 4392 DR_OFFSET_ALIGNMENT (newdr)(newdr)->innermost.offset_alignment = BIGGEST_ALIGNMENT(((global_options.x_target_flags & (1U << 12)) != 0
) ? 32 : (((global_options.x_ix86_isa_flags & (1UL <<
15)) != 0) ? 512 : (((global_options.x_ix86_isa_flags & (
1UL << 8)) != 0) ? 256 : 128))); 4393 DR_STEP_ALIGNMENT (newdr)(newdr)->innermost.step_alignment = highest_pow2_factor (step); 4394 /* Mark as simd-lane access. */ 4395 tree arg2 = gimple_call_arg (def, 1); 4396 newdr->aux = (void *) (-1 - tree_to_uhwi (arg2)); 4397 free_data_ref (dr); 4398 datarefs->safe_push (newdr); 4399 if (dataref_groups) 4400 dataref_groups->safe_push (group_id); 4401 return opt_result::success (); 4402 } 4403 } 4404 } 4405 } 4406 free_data_ref (newdr); 4407 } 4408 4409 datarefs->safe_push (dr); 4410 if (dataref_groups) 4411 dataref_groups->safe_push (group_id); 4412 return opt_result::success (); 4413} 4414 4415/* Function vect_analyze_data_refs. 4416 4417 Find all the data references in the loop or basic block. 4418 4419 The general structure of the analysis of data refs in the vectorizer is as 4420 follows: 4421 1- vect_analyze_data_refs(loop/bb): call 4422 compute_data_dependences_for_loop/bb to find and analyze all data-refs 4423 in the loop/bb and their dependences. 4424 2- vect_analyze_dependences(): apply dependence testing using ddrs. 4425 3- vect_analyze_drs_alignment(): check that ref_stmt.alignment is ok. 4426 4- vect_analyze_drs_access(): check that ref_stmt.step is ok. 4427 4428*/ 4429 4430opt_result 4431vect_analyze_data_refs (vec_info *vinfo, poly_uint64 *min_vf, bool *fatal) 4432{ 4433 class loop *loop = NULLnullptr; 4434 unsigned int i; 4435 struct data_reference *dr; 4436 tree scalar_type; 4437 4438 DUMP_VECT_SCOPE ("vect_analyze_data_refs")auto_dump_scope scope ("vect_analyze_data_refs", vect_location
); 4439 4440 if (loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo)) 4441 loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop; 4442 4443 /* Go through the data-refs, check that the analysis succeeded. Update 4444 pointer from stmt_vec_info struct to DR and vectype. */ 4445 4446 vec<data_reference_p> datarefs = vinfo->shared->datarefs; 4447 FOR_EACH_VEC_ELT (datarefs, i, dr)for (i = 0; (datarefs).iterate ((i), &(dr)); ++(i)) 4448 { 4449 enum { SG_NONE, GATHER, SCATTER } gatherscatter = SG_NONE; 4450 poly_uint64 vf; 4451 4452 gcc_assert (DR_REF (dr))((void)(!((dr)->ref) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4452, __FUNCTION__), 0 : 0)); 4453 stmt_vec_info stmt_info = vinfo->lookup_stmt (DR_STMT (dr)(dr)->stmt); 4454 gcc_assert (!stmt_info->dr_aux.dr)((void)(!(!stmt_info->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4454, __FUNCTION__), 0 : 0)); 4455 stmt_info->dr_aux.dr = dr; 4456 stmt_info->dr_aux.stmt = stmt_info; 4457 4458 /* Check that analysis of the data-ref succeeded. */ 4459 if (!DR_BASE_ADDRESS (dr)(dr)->innermost.base_address || !DR_OFFSET (dr)(dr)->innermost.offset || !DR_INIT (dr)(dr)->innermost.init 4460 || !DR_STEP (dr)(dr)->innermost.step) 4461 { 4462 bool maybe_gather 4463 = DR_IS_READ (dr)(dr)->is_read 4464 && !TREE_THIS_VOLATILE (DR_REF (dr))(((dr)->ref)->base.volatile_flag); 4465 bool maybe_scatter 4466 = DR_IS_WRITE (dr)(!(dr)->is_read) 4467 && !TREE_THIS_VOLATILE (DR_REF (dr))(((dr)->ref)->base.volatile_flag) 4468 && (targetm.vectorize.builtin_scatter != NULLnullptr 4469 || supports_vec_scatter_store_p ()); 4470 4471 /* If target supports vector gather loads or scatter stores, 4472 see if they can't be used. */ 4473 if (is_a <loop_vec_info> (vinfo) 4474 && !nested_in_vect_loop_p (loop, stmt_info)) 4475 { 4476 if (maybe_gather || maybe_scatter) 4477 { 4478 if (maybe_gather) 4479 gatherscatter = GATHER; 4480 else 4481 gatherscatter = SCATTER; 4482 } 4483 } 4484 4485 if (gatherscatter == SG_NONE) 4486 { 4487 if (dump_enabled_p ()) 4488 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, 4489 "not vectorized: data ref analysis " 4490 "failed %G", stmt_info->stmt); 4491 if (is_a <bb_vec_info> (vinfo)) 4492 { 4493 /* In BB vectorization the ref can still participate 4494 in dependence analysis, we just can't vectorize it. */ 4495 STMT_VINFO_VECTORIZABLE (stmt_info)(stmt_info)->vectorizable = false; 4496 continue; 4497 } 4498 return opt_result::failure_at (stmt_info->stmt, 4499 "not vectorized:" 4500 " data ref analysis failed: %G", 4501 stmt_info->stmt); 4502 } 4503 } 4504 4505 /* See if this was detected as SIMD lane access. */ 4506 if (dr->aux == (void *)-1 4507 || dr->aux == (void *)-2 4508 || dr->aux == (void *)-3 4509 || dr->aux == (void *)-4) 4510 { 4511 if (nested_in_vect_loop_p (loop, stmt_info)) 4512 return opt_result::failure_at (stmt_info->stmt, 4513 "not vectorized:" 4514 " data ref analysis failed: %G", 4515 stmt_info->stmt); 4516 STMT_VINFO_SIMD_LANE_ACCESS_P (stmt_info)(stmt_info)->simd_lane_access_p 4517 = -(uintptr_t) dr->aux; 4518 } 4519 4520 tree base = get_base_address (DR_REF (dr)(dr)->ref); 4521 if (base && VAR_P (base)(((enum tree_code) (base)->base.code) == VAR_DECL) && DECL_NONALIASED (base)((tree_check ((base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4521, __FUNCTION__, (VAR_DECL)))->base.nothrow_flag)) 4522 { 4523 if (dump_enabled_p ()) 4524 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, 4525 "not vectorized: base object not addressable " 4526 "for stmt: %G", stmt_info->stmt); 4527 if (is_a <bb_vec_info> (vinfo)) 4528 { 4529 /* In BB vectorization the ref can still participate 4530 in dependence analysis, we just can't vectorize it. */ 4531 STMT_VINFO_VECTORIZABLE (stmt_info)(stmt_info)->vectorizable = false; 4532 continue; 4533 } 4534 return opt_result::failure_at (stmt_info->stmt, 4535 "not vectorized: base object not" 4536 " addressable for stmt: %G", 4537 stmt_info->stmt); 4538 } 4539 4540 if (is_a <loop_vec_info> (vinfo) 4541 && DR_STEP (dr)(dr)->innermost.step 4542 && TREE_CODE (DR_STEP (dr))((enum tree_code) ((dr)->innermost.step)->base.code) != INTEGER_CST) 4543 { 4544 if (nested_in_vect_loop_p (loop, stmt_info)) 4545 return opt_result::failure_at (stmt_info->stmt, 4546 "not vectorized: " 4547 "not suitable for strided load %G", 4548 stmt_info->stmt); 4549 STMT_VINFO_STRIDED_P (stmt_info)(stmt_info)->strided_p = true; 4550 } 4551 4552 /* Update DR field in stmt_vec_info struct. */ 4553 4554 /* If the dataref is in an inner-loop of the loop that is considered for 4555 for vectorization, we also want to analyze the access relative to 4556 the outer-loop (DR contains information only relative to the 4557 inner-most enclosing loop). We do that by building a reference to the 4558 first location accessed by the inner-loop, and analyze it relative to 4559 the outer-loop. */ 4560 if (loop && nested_in_vect_loop_p (loop, stmt_info)) 4561 { 4562 /* Build a reference to the first location accessed by the 4563 inner loop: *(BASE + INIT + OFFSET). By construction, 4564 this address must be invariant in the inner loop, so we 4565 can consider it as being used in the outer loop. */ 4566 tree base = unshare_expr (DR_BASE_ADDRESS (dr)(dr)->innermost.base_address); 4567 tree offset = unshare_expr (DR_OFFSET (dr)(dr)->innermost.offset); 4568 tree init = unshare_expr (DR_INIT (dr)(dr)->innermost.init); 4569 tree init_offset = fold_build2 (PLUS_EXPR, TREE_TYPE (offset),fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4569, __FUNCTION__))->typed.type), init, offset ) 4570 init, offset)fold_build2_loc (((location_t) 0), PLUS_EXPR, ((contains_struct_check
((offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4569, __FUNCTION__))->typed.type), init, offset ); 4571 tree init_addr = fold_build_pointer_plus (base, init_offset)fold_build_pointer_plus_loc (((location_t) 0), base, init_offset
); 4572 tree init_ref = build_fold_indirect_ref (init_addr)build_fold_indirect_ref_loc (((location_t) 0), init_addr); 4573 4574 if (dump_enabled_p ()) 4575 dump_printf_loc (MSG_NOTE, vect_location, 4576 "analyze in outer loop: %T\n", init_ref); 4577 4578 opt_result res 4579 = dr_analyze_innermost (&STMT_VINFO_DR_WRT_VEC_LOOP (stmt_info)(stmt_info)->dr_wrt_vec_loop, 4580 init_ref, loop, stmt_info->stmt); 4581 if (!res) 4582 /* dr_analyze_innermost already explained the failure. */ 4583 return res; 4584 4585 if (dump_enabled_p ()) 4586 dump_printf_loc (MSG_NOTE, vect_location, 4587 "\touter base_address: %T\n" 4588 "\touter offset from base address: %T\n" 4589 "\touter constant offset from base address: %T\n" 4590 "\touter step: %T\n" 4591 "\touter base alignment: %d\n\n" 4592 "\touter base misalignment: %d\n" 4593 "\touter offset alignment: %d\n" 4594 "\touter step alignment: %d\n", 4595 STMT_VINFO_DR_BASE_ADDRESS (stmt_info)(stmt_info)->dr_wrt_vec_loop.base_address, 4596 STMT_VINFO_DR_OFFSET (stmt_info)(stmt_info)->dr_wrt_vec_loop.offset, 4597 STMT_VINFO_DR_INIT (stmt_info)(stmt_info)->dr_wrt_vec_loop.init, 4598 STMT_VINFO_DR_STEP (stmt_info)(stmt_info)->dr_wrt_vec_loop.step, 4599 STMT_VINFO_DR_BASE_ALIGNMENT (stmt_info)(stmt_info)->dr_wrt_vec_loop.base_alignment, 4600 STMT_VINFO_DR_BASE_MISALIGNMENT (stmt_info)(stmt_info)->dr_wrt_vec_loop.base_misalignment, 4601 STMT_VINFO_DR_OFFSET_ALIGNMENT (stmt_info)(stmt_info)->dr_wrt_vec_loop.offset_alignment, 4602 STMT_VINFO_DR_STEP_ALIGNMENT (stmt_info)(stmt_info)->dr_wrt_vec_loop.step_alignment); 4603 } 4604 4605 /* Set vectype for STMT. */ 4606 scalar_type = TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4606, __FUNCTION__))->typed.type); 4607 tree vectype = get_vectype_for_scalar_type (vinfo, scalar_type); 4608 if (!vectype) 4609 { 4610 if (dump_enabled_p ()) 4611 { 4612 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, 4613 "not vectorized: no vectype for stmt: %G", 4614 stmt_info->stmt); 4615 dump_printf (MSG_MISSED_OPTIMIZATION, " scalar_type: "); 4616 dump_generic_expr (MSG_MISSED_OPTIMIZATION, TDF_DETAILS, 4617 scalar_type); 4618 dump_printf (MSG_MISSED_OPTIMIZATION, "\n"); 4619 } 4620 4621 if (is_a <bb_vec_info> (vinfo)) 4622 { 4623 /* No vector type is fine, the ref can still participate 4624 in dependence analysis, we just can't vectorize it. */ 4625 STMT_VINFO_VECTORIZABLE (stmt_info)(stmt_info)->vectorizable = false; 4626 continue; 4627 } 4628 if (fatal) 4629 *fatal = false; 4630 return opt_result::failure_at (stmt_info->stmt, 4631 "not vectorized:" 4632 " no vectype for stmt: %G" 4633 " scalar_type: %T\n", 4634 stmt_info->stmt, scalar_type); 4635 } 4636 else 4637 { 4638 if (dump_enabled_p ()) 4639 dump_printf_loc (MSG_NOTE, vect_location, 4640 "got vectype for stmt: %G%T\n", 4641 stmt_info->stmt, vectype); 4642 } 4643 4644 /* Adjust the minimal vectorization factor according to the 4645 vector type. */ 4646 vf = TYPE_VECTOR_SUBPARTS (vectype); 4647 *min_vf = upper_bound (*min_vf, vf); 4648 4649 /* Leave the BB vectorizer to pick the vector type later, based on 4650 the final dataref group size and SLP node size. */ 4651 if (is_a <loop_vec_info> (vinfo)) 4652 STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype = vectype; 4653 4654 if (gatherscatter != SG_NONE) 4655 { 4656 gather_scatter_info gs_info; 4657 if (!vect_check_gather_scatter (stmt_info, 4658 as_a <loop_vec_info> (vinfo), 4659 &gs_info) 4660 || !get_vectype_for_scalar_type (vinfo, 4661 TREE_TYPE (gs_info.offset)((contains_struct_check ((gs_info.offset), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4661, __FUNCTION__))->typed.type))) 4662 { 4663 if (fatal) 4664 *fatal = false; 4665 return opt_result::failure_at 4666 (stmt_info->stmt, 4667 (gatherscatter == GATHER) 4668 ? "not vectorized: not suitable for gather load %G" 4669 : "not vectorized: not suitable for scatter store %G", 4670 stmt_info->stmt); 4671 } 4672 STMT_VINFO_GATHER_SCATTER_P (stmt_info)(stmt_info)->gather_scatter_p = gatherscatter; 4673 } 4674 } 4675 4676 /* We used to stop processing and prune the list here. Verify we no 4677 longer need to. */ 4678 gcc_assert (i == datarefs.length ())((void)(!(i == datarefs.length ()) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4678, __FUNCTION__), 0 : 0)); 4679 4680 return opt_result::success (); 4681} 4682 4683 4684/* Function vect_get_new_vect_var. 4685 4686 Returns a name for a new variable. The current naming scheme appends the 4687 prefix "vect_" or "vect_p" (depending on the value of VAR_KIND) to 4688 the name of vectorizer generated variables, and appends that to NAME if 4689 provided. */ 4690 4691tree 4692vect_get_new_vect_var (tree type, enum vect_var_kind var_kind, const char *name) 4693{ 4694 const char *prefix; 4695 tree new_vect_var; 4696 4697 switch (var_kind) 4698 { 4699 case vect_simple_var: 4700 prefix = "vect"; 4701 break; 4702 case vect_scalar_var: 4703 prefix = "stmp"; 4704 break; 4705 case vect_mask_var: 4706 prefix = "mask"; 4707 break; 4708 case vect_pointer_var: 4709 prefix = "vectp"; 4710 break; 4711 default: 4712 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4712, __FUNCTION__)); 4713 } 4714 4715 if (name) 4716 { 4717 char* tmp = concat (prefix, "_", name, NULLnullptr); 4718 new_vect_var = create_tmp_reg (type, tmp); 4719 free (tmp); 4720 } 4721 else 4722 new_vect_var = create_tmp_reg (type, prefix); 4723 4724 return new_vect_var; 4725} 4726 4727/* Like vect_get_new_vect_var but return an SSA name. */ 4728 4729tree 4730vect_get_new_ssa_name (tree type, enum vect_var_kind var_kind, const char *name) 4731{ 4732 const char *prefix; 4733 tree new_vect_var; 4734 4735 switch (var_kind) 4736 { 4737 case vect_simple_var: 4738 prefix = "vect"; 4739 break; 4740 case vect_scalar_var: 4741 prefix = "stmp"; 4742 break; 4743 case vect_pointer_var: 4744 prefix = "vectp"; 4745 break; 4746 default: 4747 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4747, __FUNCTION__)); 4748 } 4749 4750 if (name) 4751 { 4752 char* tmp = concat (prefix, "_", name, NULLnullptr); 4753 new_vect_var = make_temp_ssa_name (type, NULLnullptr, tmp); 4754 free (tmp); 4755 } 4756 else 4757 new_vect_var = make_temp_ssa_name (type, NULLnullptr, prefix); 4758 4759 return new_vect_var; 4760} 4761 4762/* Duplicate points-to info on NAME from DR_INFO. */ 4763 4764static void 4765vect_duplicate_ssa_name_ptr_info (tree name, dr_vec_info *dr_info) 4766{ 4767 duplicate_ssa_name_ptr_info (name, DR_PTR_INFO (dr_info->dr)(dr_info->dr)->alias.ptr_info); 4768 /* DR_PTR_INFO is for a base SSA name, not including constant or 4769 variable offsets in the ref so its alignment info does not apply. */ 4770 mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (name)(tree_check ((name), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4770, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info); 4771} 4772 4773/* Function vect_create_addr_base_for_vector_ref. 4774 4775 Create an expression that computes the address of the first memory location 4776 that will be accessed for a data reference. 4777 4778 Input: 4779 STMT_INFO: The statement containing the data reference. 4780 NEW_STMT_LIST: Must be initialized to NULL_TREE or a statement list. 4781 OFFSET: Optional. If supplied, it is be added to the initial address. 4782 LOOP: Specify relative to which loop-nest should the address be computed. 4783 For example, when the dataref is in an inner-loop nested in an 4784 outer-loop that is now being vectorized, LOOP can be either the 4785 outer-loop, or the inner-loop. The first memory location accessed 4786 by the following dataref ('in' points to short): 4787 4788 for (i=0; i<N; i++) 4789 for (j=0; j<M; j++) 4790 s += in[i+j] 4791 4792 is as follows: 4793 if LOOP=i_loop: &in (relative to i_loop) 4794 if LOOP=j_loop: &in+i*2B (relative to j_loop) 4795 4796 Output: 4797 1. Return an SSA_NAME whose value is the address of the memory location of 4798 the first vector of the data reference. 4799 2. If new_stmt_list is not NULL_TREE after return then the caller must insert 4800 these statement(s) which define the returned SSA_NAME. 4801 4802 FORNOW: We are only handling array accesses with step 1. */ 4803 4804tree 4805vect_create_addr_base_for_vector_ref (vec_info *vinfo, stmt_vec_info stmt_info, 4806 gimple_seq *new_stmt_list, 4807 tree offset) 4808{ 4809 dr_vec_info *dr_info = STMT_VINFO_DR_INFO (stmt_info)(((void)(!((stmt_info)->dr_aux.stmt == (stmt_info)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4809, __FUNCTION__), 0 : 0)), &(stmt_info)->dr_aux); 4810 struct data_reference *dr = dr_info->dr; 4811 const char *base_name; 4812 tree addr_base; 4813 tree dest; 4814 gimple_seq seq = NULLnullptr; 4815 tree vect_ptr_type; 4816 loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo); 4817 innermost_loop_behavior *drb = vect_dr_behavior (vinfo, dr_info); 4818 4819 tree data_ref_base = unshare_expr (drb->base_address); 4820 tree base_offset = unshare_expr (get_dr_vinfo_offset (vinfo, dr_info, true)); 4821 tree init = unshare_expr (drb->init); 4822 4823 if (loop_vinfo) 4824 base_name = get_name (data_ref_base); 4825 else 4826 { 4827 base_offset = ssize_int (0)size_int_kind (0, stk_ssizetype); 4828 init = ssize_int (0)size_int_kind (0, stk_ssizetype); 4829 base_name = get_name (DR_REF (dr)(dr)->ref); 4830 } 4831 4832 /* Create base_offset */ 4833 base_offset = size_binop (PLUS_EXPR,size_binop_loc (((location_t) 0), PLUS_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], base_offset
), fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], init)) 4834 fold_convert (sizetype, base_offset),size_binop_loc (((location_t) 0), PLUS_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], base_offset
), fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], init)) 4835 fold_convert (sizetype, init))size_binop_loc (((location_t) 0), PLUS_EXPR, fold_convert_loc
(((location_t) 0), sizetype_tab[(int) stk_sizetype], base_offset
), fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], init)); 4836 4837 if (offset) 4838 { 4839 offset = fold_convert (sizetype, offset)fold_convert_loc (((location_t) 0), sizetype_tab[(int) stk_sizetype
], offset); 4840 base_offset = fold_build2 (PLUS_EXPR, sizetype,fold_build2_loc (((location_t) 0), PLUS_EXPR, sizetype_tab[(int
) stk_sizetype], base_offset, offset ) 4841 base_offset, offset)fold_build2_loc (((location_t) 0), PLUS_EXPR, sizetype_tab[(int
) stk_sizetype], base_offset, offset ); 4842 } 4843 4844 /* base + base_offset */ 4845 if (loop_vinfo) 4846 addr_base = fold_build_pointer_plus (data_ref_base, base_offset)fold_build_pointer_plus_loc (((location_t) 0), data_ref_base,
base_offset); 4847 else 4848 addr_base = build1 (ADDR_EXPR, 4849 build_pointer_type (TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4849, __FUNCTION__))->typed.type)), 4850 /* Strip zero offset components since we don't need 4851 them and they can confuse late diagnostics if 4852 we CSE them wrongly. See PR106904 for example. */ 4853 unshare_expr (strip_zero_offset_components 4854 (DR_REF (dr)(dr)->ref))); 4855 4856 vect_ptr_type = build_pointer_type (TREE_TYPE (DR_REF (dr))((contains_struct_check (((dr)->ref), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4856, __FUNCTION__))->typed.type)); 4857 dest = vect_get_new_vect_var (vect_ptr_type, vect_pointer_var, base_name); 4858 addr_base = force_gimple_operand (addr_base, &seq, true, dest); 4859 gimple_seq_add_seq (new_stmt_list, seq); 4860 4861 if (DR_PTR_INFO (dr)(dr)->alias.ptr_info 4862 && TREE_CODE (addr_base)((enum tree_code) (addr_base)->base.code) == SSA_NAME 4863 /* We should only duplicate pointer info to newly created SSA names. */ 4864 && SSA_NAME_VAR (addr_base)((tree_check ((addr_base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4864, __FUNCTION__, (SSA_NAME)))->ssa_name.var == (tree)
nullptr || ((enum tree_code) ((addr_base)->ssa_name.var)->
base.code) == IDENTIFIER_NODE ? (tree) nullptr : (addr_base)->
ssa_name.var) == dest) 4865 { 4866 gcc_assert (!SSA_NAME_PTR_INFO (addr_base))((void)(!(!(tree_check ((addr_base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4866, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4866, __FUNCTION__), 0 : 0)); 4867 vect_duplicate_ssa_name_ptr_info (addr_base, dr_info); 4868 } 4869 4870 if (dump_enabled_p ()) 4871 dump_printf_loc (MSG_NOTE, vect_location, "created %T\n", addr_base); 4872 4873 return addr_base; 4874} 4875 4876 4877/* Function vect_create_data_ref_ptr. 4878 4879 Create a new pointer-to-AGGR_TYPE variable (ap), that points to the first 4880 location accessed in the loop by STMT_INFO, along with the def-use update 4881 chain to appropriately advance the pointer through the loop iterations. 4882 Also set aliasing information for the pointer. This pointer is used by 4883 the callers to this function to create a memory reference expression for 4884 vector load/store access. 4885 4886 Input: 4887 1. STMT_INFO: a stmt that references memory. Expected to be of the form 4888 GIMPLE_ASSIGN <name, data-ref> or 4889 GIMPLE_ASSIGN <data-ref, name>. 4890 2. AGGR_TYPE: the type of the reference, which should be either a vector 4891 or an array. 4892 3. AT_LOOP: the loop where the vector memref is to be created. 4893 4. OFFSET (optional): a byte offset to be added to the initial address 4894 accessed by the data-ref in STMT_INFO. 4895 5. BSI: location where the new stmts are to be placed if there is no loop 4896 6. ONLY_INIT: indicate if ap is to be updated in the loop, or remain 4897 pointing to the initial address. 4898 8. IV_STEP (optional, defaults to NULL): the amount that should be added 4899 to the IV during each iteration of the loop. NULL says to move 4900 by one copy of AGGR_TYPE up or down, depending on the step of the 4901 data reference. 4902 4903 Output: 4904 1. Declare a new ptr to vector_type, and have it point to the base of the 4905 data reference (initial addressed accessed by the data reference). 4906 For example, for vector of type V8HI, the following code is generated: 4907 4908 v8hi *ap; 4909 ap = (v8hi *)initial_address; 4910 4911 if OFFSET is not supplied: 4912 initial_address = &a[init]; 4913 if OFFSET is supplied: 4914 initial_address = &a[init] + OFFSET; 4915 if BYTE_OFFSET is supplied: 4916 initial_address = &a[init] + BYTE_OFFSET; 4917 4918 Return the initial_address in INITIAL_ADDRESS. 4919 4920 2. If ONLY_INIT is true, just return the initial pointer. Otherwise, also 4921 update the pointer in each iteration of the loop. 4922 4923 Return the increment stmt that updates the pointer in PTR_INCR. 4924 4925 3. Return the pointer. */ 4926 4927tree 4928vect_create_data_ref_ptr (vec_info *vinfo, stmt_vec_info stmt_info, 4929 tree aggr_type, class loop *at_loop, tree offset, 4930 tree *initial_address, gimple_stmt_iterator *gsi, 4931 gimple **ptr_incr, bool only_init, 4932 tree iv_step) 4933{ 4934 const char *base_name; 4935 loop_vec_info loop_vinfo = dyn_cast <loop_vec_info> (vinfo); 4936 class loop *loop = NULLnullptr; 4937 bool nested_in_vect_loop = false; 4938 class loop *containing_loop = NULLnullptr; 4939 tree aggr_ptr_type; 4940 tree aggr_ptr; 4941 tree new_temp; 4942 gimple_seq new_stmt_list = NULLnullptr; 4943 edge pe = NULLnullptr; 4944 basic_block new_bb; 4945 tree aggr_ptr_init; 4946 dr_vec_info *dr_info = STMT_VINFO_DR_INFO (stmt_info)(((void)(!((stmt_info)->dr_aux.stmt == (stmt_info)) ? fancy_abort
("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4946, __FUNCTION__), 0 : 0)), &(stmt_info)->dr_aux); 4947 struct data_reference *dr = dr_info->dr; 4948 tree aptr; 4949 gimple_stmt_iterator incr_gsi; 4950 bool insert_after; 4951 tree indx_before_incr, indx_after_incr; 4952 gimple *incr; 4953 bb_vec_info bb_vinfo = dyn_cast <bb_vec_info> (vinfo); 4954 4955 gcc_assert (iv_step != NULL_TREE((void)(!(iv_step != (tree) nullptr || ((enum tree_code) (aggr_type
)->base.code) == ARRAY_TYPE || ((enum tree_code) (aggr_type
)->base.code) == VECTOR_TYPE) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4957, __FUNCTION__), 0 : 0)) 4956 || TREE_CODE (aggr_type) == ARRAY_TYPE((void)(!(iv_step != (tree) nullptr || ((enum tree_code) (aggr_type
)->base.code) == ARRAY_TYPE || ((enum tree_code) (aggr_type
)->base.code) == VECTOR_TYPE) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4957, __FUNCTION__), 0 : 0)) 4957 || TREE_CODE (aggr_type) == VECTOR_TYPE)((void)(!(iv_step != (tree) nullptr || ((enum tree_code) (aggr_type
)->base.code) == ARRAY_TYPE || ((enum tree_code) (aggr_type
)->base.code) == VECTOR_TYPE) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4957, __FUNCTION__), 0 : 0)); 4958 4959 if (loop_vinfo) 4960 { 4961 loop = LOOP_VINFO_LOOP (loop_vinfo)(loop_vinfo)->loop; 4962 nested_in_vect_loop = nested_in_vect_loop_p (loop, stmt_info); 4963 containing_loop = (gimple_bb (stmt_info->stmt))->loop_father; 4964 pe = loop_preheader_edge (loop); 4965 } 4966 else 4967 { 4968 gcc_assert (bb_vinfo)((void)(!(bb_vinfo) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4968, __FUNCTION__), 0 : 0)); 4969 only_init = true; 4970 *ptr_incr = NULLnullptr; 4971 } 4972 4973 /* Create an expression for the first address accessed by this load 4974 in LOOP. */ 4975 base_name = get_name (DR_BASE_ADDRESS (dr)(dr)->innermost.base_address); 4976 4977 if (dump_enabled_p ()) 4978 { 4979 tree dr_base_type = TREE_TYPE (DR_BASE_OBJECT (dr))((contains_struct_check (((dr)->indices.base_object), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 4979, __FUNCTION__))->typed.type); 4980 dump_printf_loc (MSG_NOTE, vect_location, 4981 "create %s-pointer variable to type: %T", 4982 get_tree_code_name (TREE_CODE (aggr_type)((enum tree_code) (aggr_type)->base.code)), 4983 aggr_type); 4984 if (TREE_CODE (dr_base_type)((enum tree_code) (dr_base_type)->base.code) == ARRAY_TYPE) 4985 dump_printf (MSG_NOTE, " vectorizing an array ref: "); 4986 else if (TREE_CODE (dr_base_type)((enum tree_code) (dr_base_type)->base.code) == VECTOR_TYPE) 4987 dump_printf (MSG_NOTE, " vectorizing a vector ref: "); 4988 else if (TREE_CODE (dr_base_type)((enum tree_code) (dr_base_type)->base.code) == RECORD_TYPE) 4989 dump_printf (MSG_NOTE, " vectorizing a record based array ref: "); 4990 else 4991 dump_printf (MSG_NOTE, " vectorizing a pointer ref: "); 4992 dump_printf (MSG_NOTE, "%T\n", DR_BASE_OBJECT (dr)(dr)->indices.base_object); 4993 } 4994 4995 /* (1) Create the new aggregate-pointer variable. 4996 Vector and array types inherit the alias set of their component 4997 type by default so we need to use a ref-all pointer if the data 4998 reference does not conflict with the created aggregated data 4999 reference because it is not addressable. */ 5000 bool need_ref_all = false; 5001 if (!alias_sets_conflict_p (get_alias_set (aggr_type), 5002 get_alias_set (DR_REF (dr)(dr)->ref))) 5003 need_ref_all = true; 5004 /* Likewise for any of the data references in the stmt group. */ 5005 else if (DR_GROUP_SIZE (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5005, __FUNCTION__), 0 : 0)), (stmt_info)->size) > 1) 5006 { 5007 stmt_vec_info sinfo = DR_GROUP_FIRST_ELEMENT (stmt_info)(((void)(!((stmt_info)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5007, __FUNCTION__), 0 : 0)), (stmt_info)->first_element
); 5008 do 5009 { 5010 struct data_reference *sdr = STMT_VINFO_DATA_REF (sinfo)((sinfo)->dr_aux.dr + 0); 5011 if (!alias_sets_conflict_p (get_alias_set (aggr_type), 5012 get_alias_set (DR_REF (sdr)(sdr)->ref))) 5013 { 5014 need_ref_all = true; 5015 break; 5016 } 5017 sinfo = DR_GROUP_NEXT_ELEMENT (sinfo)(((void)(!((sinfo)->dr_aux.dr) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5017, __FUNCTION__), 0 : 0)), (sinfo)->next_element); 5018 } 5019 while (sinfo); 5020 } 5021 aggr_ptr_type = build_pointer_type_for_mode (aggr_type, ptr_mode, 5022 need_ref_all); 5023 aggr_ptr = vect_get_new_vect_var (aggr_ptr_type, vect_pointer_var, base_name); 5024 5025 5026 /* Note: If the dataref is in an inner-loop nested in LOOP, and we are 5027 vectorizing LOOP (i.e., outer-loop vectorization), we need to create two 5028 def-use update cycles for the pointer: one relative to the outer-loop 5029 (LOOP), which is what steps (3) and (4) below do. The other is relative 5030 to the inner-loop (which is the inner-most loop containing the dataref), 5031 and this is done be step (5) below. 5032 5033 When vectorizing inner-most loops, the vectorized loop (LOOP) is also the 5034 inner-most loop, and so steps (3),(4) work the same, and step (5) is 5035 redundant. Steps (3),(4) create the following: 5036 5037 vp0 = &base_addr; 5038 LOOP: vp1 = phi(vp0,vp2) 5039 ... 5040 ... 5041 vp2 = vp1 + step 5042 goto LOOP 5043 5044 If there is an inner-loop nested in loop, then step (5) will also be 5045 applied, and an additional update in the inner-loop will be created: 5046 5047 vp0 = &base_addr; 5048 LOOP: vp1 = phi(vp0,vp2) 5049 ... 5050 inner: vp3 = phi(vp1,vp4) 5051 vp4 = vp3 + inner_step 5052 if () goto inner 5053 ... 5054 vp2 = vp1 + step 5055 if () goto LOOP */ 5056 5057 /* (2) Calculate the initial address of the aggregate-pointer, and set 5058 the aggregate-pointer to point to it before the loop. */ 5059 5060 /* Create: (&(base[init_val]+offset) in the loop preheader. */ 5061 5062 new_temp = vect_create_addr_base_for_vector_ref (vinfo, 5063 stmt_info, &new_stmt_list, 5064 offset); 5065 if (new_stmt_list) 5066 { 5067 if (pe) 5068 { 5069 new_bb = gsi_insert_seq_on_edge_immediate (pe, new_stmt_list); 5070 gcc_assert (!new_bb)((void)(!(!new_bb) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5070, __FUNCTION__), 0 : 0)); 5071 } 5072 else 5073 gsi_insert_seq_before (gsi, new_stmt_list, GSI_SAME_STMT); 5074 } 5075 5076 *initial_address = new_temp; 5077 aggr_ptr_init = new_temp; 5078 5079 /* (3) Handle the updating of the aggregate-pointer inside the loop. 5080 This is needed when ONLY_INIT is false, and also when AT_LOOP is the 5081 inner-loop nested in LOOP (during outer-loop vectorization). */ 5082 5083 /* No update in loop is required. */ 5084 if (only_init && (!loop_vinfo || at_loop == loop)) 5085 aptr = aggr_ptr_init; 5086 else 5087 { 5088 /* Accesses to invariant addresses should be handled specially 5089 by the caller. */ 5090 tree step = vect_dr_behavior (vinfo, dr_info)->step; 5091 gcc_assert (!integer_zerop (step))((void)(!(!integer_zerop (step)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5091, __FUNCTION__), 0 : 0)); 5092 5093 if (iv_step == NULL_TREE(tree) nullptr) 5094 { 5095 /* The step of the aggregate pointer is the type size, 5096 negated for downward accesses. */ 5097 iv_step = TYPE_SIZE_UNIT (aggr_type)((tree_class_check ((aggr_type), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5097, __FUNCTION__))->type_common.size_unit); 5098 if (tree_int_cst_sgn (step) == -1) 5099 iv_step = fold_build1 (NEGATE_EXPR, TREE_TYPE (iv_step), iv_step)fold_build1_loc (((location_t) 0), NEGATE_EXPR, ((contains_struct_check
((iv_step), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5099, __FUNCTION__))->typed.type), iv_step ); 5100 } 5101 5102 standard_iv_increment_position (loop, &incr_gsi, &insert_after); 5103 5104 create_iv (aggr_ptr_init, 5105 fold_convert (aggr_ptr_type, iv_step)fold_convert_loc (((location_t) 0), aggr_ptr_type, iv_step), 5106 aggr_ptr, loop, &incr_gsi, insert_after, 5107 &indx_before_incr, &indx_after_incr); 5108 incr = gsi_stmt (incr_gsi); 5109 5110 /* Copy the points-to information if it exists. */ 5111 if (DR_PTR_INFO (dr)(dr)->alias.ptr_info) 5112 { 5113 vect_duplicate_ssa_name_ptr_info (indx_before_incr, dr_info); 5114 vect_duplicate_ssa_name_ptr_info (indx_after_incr, dr_info); 5115 } 5116 if (ptr_incr) 5117 *ptr_incr = incr; 5118 5119 aptr = indx_before_incr; 5120 } 5121 5122 if (!nested_in_vect_loop || only_init) 5123 return aptr; 5124 5125 5126 /* (4) Handle the updating of the aggregate-pointer inside the inner-loop 5127 nested in LOOP, if exists. */ 5128 5129 gcc_assert (nested_in_vect_loop)((void)(!(nested_in_vect_loop) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5129, __FUNCTION__), 0 : 0)); 5130 if (!only_init) 5131 { 5132 standard_iv_increment_position (containing_loop, &incr_gsi, 5133 &insert_after); 5134 create_iv (aptr, fold_convert (aggr_ptr_type, DR_STEP (dr))fold_convert_loc (((location_t) 0), aggr_ptr_type, (dr)->innermost
.step), aggr_ptr, 5135 containing_loop, &incr_gsi, insert_after, &indx_before_incr, 5136 &indx_after_incr); 5137 incr = gsi_stmt (incr_gsi); 5138 5139 /* Copy the points-to information if it exists. */ 5140 if (DR_PTR_INFO (dr)(dr)->alias.ptr_info) 5141 { 5142 vect_duplicate_ssa_name_ptr_info (indx_before_incr, dr_info); 5143 vect_duplicate_ssa_name_ptr_info (indx_after_incr, dr_info); 5144 } 5145 if (ptr_incr) 5146 *ptr_incr = incr; 5147 5148 return indx_before_incr; 5149 } 5150 else 5151 gcc_unreachable ()(fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5151, __FUNCTION__)); 5152} 5153 5154 5155/* Function bump_vector_ptr 5156 5157 Increment a pointer (to a vector type) by vector-size. If requested, 5158 i.e. if PTR-INCR is given, then also connect the new increment stmt 5159 to the existing def-use update-chain of the pointer, by modifying 5160 the PTR_INCR as illustrated below: 5161 5162 The pointer def-use update-chain before this function: 5163 DATAREF_PTR = phi (p_0, p_2) 5164 .... 5165 PTR_INCR: p_2 = DATAREF_PTR + step 5166 5167 The pointer def-use update-chain after this function: 5168 DATAREF_PTR = phi (p_0, p_2) 5169 .... 5170 NEW_DATAREF_PTR = DATAREF_PTR + BUMP 5171 .... 5172 PTR_INCR: p_2 = NEW_DATAREF_PTR + step 5173 5174 Input: 5175 DATAREF_PTR - ssa_name of a pointer (to vector type) that is being updated 5176 in the loop. 5177 PTR_INCR - optional. The stmt that updates the pointer in each iteration of 5178 the loop. The increment amount across iterations is expected 5179 to be vector_size. 5180 BSI - location where the new update stmt is to be placed. 5181 STMT_INFO - the original scalar memory-access stmt that is being vectorized. 5182 BUMP - optional. The offset by which to bump the pointer. If not given, 5183 the offset is assumed to be vector_size. 5184 5185 Output: Return NEW_DATAREF_PTR as illustrated above. 5186 5187*/ 5188 5189tree 5190bump_vector_ptr (vec_info *vinfo, 5191 tree dataref_ptr, gimple *ptr_incr, gimple_stmt_iterator *gsi, 5192 stmt_vec_info stmt_info, tree bump) 5193{ 5194 struct data_reference *dr = STMT_VINFO_DATA_REF (stmt_info)((stmt_info)->dr_aux.dr + 0); 5195 tree vectype = STMT_VINFO_VECTYPE (stmt_info)(stmt_info)->vectype; 5196 tree update = TYPE_SIZE_UNIT (vectype)((tree_class_check ((vectype), (tcc_type), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5196, __FUNCTION__))->type_common.size_unit); 5197 gimple *incr_stmt; 5198 ssa_op_iter iter; 5199 use_operand_p use_p; 5200 tree new_dataref_ptr; 5201 5202 if (bump) 5203 update = bump; 5204 5205 if (TREE_CODE (dataref_ptr)((enum tree_code) (dataref_ptr)->base.code) == SSA_NAME) 5206 new_dataref_ptr = copy_ssa_name (dataref_ptr); 5207 else if (is_gimple_min_invariant (dataref_ptr)) 5208 /* When possible avoid emitting a separate increment stmt that will 5209 force the addressed object addressable. */ 5210 return build1 (ADDR_EXPR, TREE_TYPE (dataref_ptr)((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5210, __FUNCTION__))->typed.type), 5211 fold_build2 (MEM_REF,fold_build2_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type), dataref_ptr, fold_convert_loc
(((location_t) 0), global_trees[TI_PTR_TYPE], update) ) 5212 TREE_TYPE (TREE_TYPE (dataref_ptr)),fold_build2_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type), dataref_ptr, fold_convert_loc
(((location_t) 0), global_trees[TI_PTR_TYPE], update) ) 5213 dataref_ptr,fold_build2_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type), dataref_ptr, fold_convert_loc
(((location_t) 0), global_trees[TI_PTR_TYPE], update) ) 5214 fold_convert (ptr_type_node, update))fold_build2_loc (((location_t) 0), MEM_REF, ((contains_struct_check
((((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type)), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5212, __FUNCTION__))->typed.type), dataref_ptr, fold_convert_loc
(((location_t) 0), global_trees[TI_PTR_TYPE], update) )); 5215 else 5216 new_dataref_ptr = make_ssa_name (TREE_TYPE (dataref_ptr)((contains_struct_check ((dataref_ptr), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5216, __FUNCTION__))->typed.type)); 5217 incr_stmt = gimple_build_assign (new_dataref_ptr, POINTER_PLUS_EXPR, 5218 dataref_ptr, update); 5219 vect_finish_stmt_generation (vinfo, stmt_info, incr_stmt, gsi); 5220 /* Fold the increment, avoiding excessive chains use-def chains of 5221 those, leading to compile-time issues for passes until the next 5222 forwprop pass which would do this as well. */ 5223 gimple_stmt_iterator fold_gsi = gsi_for_stmt (incr_stmt); 5224 if (fold_stmt (&fold_gsi, follow_all_ssa_edges)) 5225 { 5226 incr_stmt = gsi_stmt (fold_gsi); 5227 update_stmt (incr_stmt); 5228 } 5229 5230 /* Copy the points-to information if it exists. */ 5231 if (DR_PTR_INFO (dr)(dr)->alias.ptr_info) 5232 { 5233 duplicate_ssa_name_ptr_info (new_dataref_ptr, DR_PTR_INFO (dr)(dr)->alias.ptr_info); 5234 mark_ptr_info_alignment_unknown (SSA_NAME_PTR_INFO (new_dataref_ptr)(tree_check ((new_dataref_ptr), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5234, __FUNCTION__, (SSA_NAME)))->ssa_name.info.ptr_info); 5235 } 5236 5237 if (!ptr_incr) 5238 return new_dataref_ptr; 5239 5240 /* Update the vector-pointer's cross-iteration increment. */ 5241 FOR_EACH_SSA_USE_OPERAND (use_p, ptr_incr, iter, SSA_OP_USE)for (use_p = op_iter_init_use (&(iter), ptr_incr, 0x01); !
op_iter_done (&(iter)); use_p = op_iter_next_use (&(iter
))) 5242 { 5243 tree use = USE_FROM_PTR (use_p)get_use_from_ptr (use_p); 5244 5245 if (use == dataref_ptr) 5246 SET_USE (use_p, new_dataref_ptr)set_ssa_use_from_ptr (use_p, new_dataref_ptr); 5247 else 5248 gcc_assert (operand_equal_p (use, update, 0))((void)(!(operand_equal_p (use, update, 0)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5248, __FUNCTION__), 0 : 0)); 5249 } 5250 5251 return new_dataref_ptr; 5252} 5253 5254 5255/* Copy memory reference info such as base/clique from the SRC reference 5256 to the DEST MEM_REF. */ 5257 5258void 5259vect_copy_ref_info (tree dest, tree src) 5260{ 5261 if (TREE_CODE (dest)((enum tree_code) (dest)->base.code) != MEM_REF) 5262 return; 5263 5264 tree src_base = src; 5265 while (handled_component_p (src_base)) 5266 src_base = TREE_OPERAND (src_base, 0)(*((const_cast<tree*> (tree_operand_check ((src_base), (
0), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5266, __FUNCTION__))))); 5267 if (TREE_CODE (src_base)((enum tree_code) (src_base)->base.code) != MEM_REF 5268 && TREE_CODE (src_base)((enum tree_code) (src_base)->base.code) != TARGET_MEM_REF) 5269 return; 5270 5271 MR_DEPENDENCE_CLIQUE (dest)((tree_check2 ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5271, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique) = MR_DEPENDENCE_CLIQUE (src_base)((tree_check2 ((src_base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5271, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.clique); 5272 MR_DEPENDENCE_BASE (dest)((tree_check2 ((dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5272, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base) = MR_DEPENDENCE_BASE (src_base)((tree_check2 ((src_base), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5272, __FUNCTION__, (MEM_REF), (TARGET_MEM_REF)))->base.
u.dependence_info.base); 5273} 5274 5275 5276/* Function vect_create_destination_var. 5277 5278 Create a new temporary of type VECTYPE. */ 5279 5280tree 5281vect_create_destination_var (tree scalar_dest, tree vectype) 5282{ 5283 tree vec_dest; 5284 const char *name; 5285 char *new_name; 5286 tree type; 5287 enum vect_var_kind kind; 5288 5289 kind = vectype 5290 ? VECTOR_BOOLEAN_TYPE_P (vectype)(((enum tree_code) (vectype)->base.code) == VECTOR_TYPE &&
((enum tree_code) (((contains_struct_check ((vectype), (TS_TYPED
), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5290, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
) 5291 ? vect_mask_var 5292 : vect_simple_var 5293 : vect_scalar_var; 5294 type = vectype ? vectype : TREE_TYPE (scalar_dest)((contains_struct_check ((scalar_dest), (TS_TYPED), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5294, __FUNCTION__))->typed.type); 5295 5296 gcc_assert (TREE_CODE (scalar_dest) == SSA_NAME)((void)(!(((enum tree_code) (scalar_dest)->base.code) == SSA_NAME
) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5296, __FUNCTION__), 0 : 0)); 5297 5298 name = get_name (scalar_dest); 5299 if (name) 5300 new_name = xasprintf ("%s_%u", name, SSA_NAME_VERSION (scalar_dest)(tree_check ((scalar_dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5300, __FUNCTION__, (SSA_NAME)))->base.u.version); 5301 else 5302 new_name = xasprintf ("_%u", SSA_NAME_VERSION (scalar_dest)(tree_check ((scalar_dest), "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5302, __FUNCTION__, (SSA_NAME)))->base.u.version); 5303 vec_dest = vect_get_new_vect_var (type, kind, new_name); 5304 free (new_name); 5305 5306 return vec_dest; 5307} 5308 5309/* Function vect_grouped_store_supported. 5310 5311 Returns TRUE if interleave high and interleave low permutations 5312 are supported, and FALSE otherwise. */ 5313 5314bool 5315vect_grouped_store_supported (tree vectype, unsigned HOST_WIDE_INTlong count) 5316{ 5317 machine_mode mode = TYPE_MODE (vectype)((((enum tree_code) ((tree_class_check ((vectype), (tcc_type)
, "/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5317, __FUNCTION__)))->base.code) == VECTOR_TYPE) ? vector_type_mode
(vectype) : (vectype)->type_common.mode); 5318 5319 /* vect_permute_store_chain requires the group size to be equal to 3 or 5320 be a power of two. */ 5321 if (count != 3 && exact_log2 (count) == -1) 5322 { 5323 if (dump_enabled_p ()) 5324 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, 5325 "the size of the group of accesses" 5326 " is not a power of 2 or not eqaul to 3\n"); 5327 return false; 5328 } 5329 5330 /* Check that the permutation is supported. */ 5331 if (VECTOR_MODE_P (mode)(((enum mode_class) mode_class[mode]) == MODE_VECTOR_BOOL || (
(enum mode_class) mode_class[mode]) == MODE_VECTOR_INT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FLOAT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_FRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UFRACT || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_ACCUM || ((enum
mode_class) mode_class[mode]) == MODE_VECTOR_UACCUM)) 5332 { 5333 unsigned int i; 5334 if (count == 3) 5335 { 5336 unsigned int j0 = 0, j1 = 0, j2 = 0; 5337 unsigned int i, j; 5338 5339 unsigned int nelt; 5340 if (!GET_MODE_NUNITS (mode).is_constant (&nelt)) 5341 { 5342 if (dump_enabled_p ()) 5343 dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, 5344 "cannot handle groups of 3 stores for" 5345 " variable-length vectors\n"); 5346 return false; 5347 } 5348 5349 vec_perm_builder sel (nelt, nelt, 1); 5350 sel.quick_grow (nelt); 5351 vec_perm_indices indices; 5352 for (j = 0; j < 3; j++) 5353 { 5354 int nelt0 = ((3 - j) * nelt) % 3; 5355 int nelt1 = ((3 - j) * nelt + 1) % 3; 5356 int nelt2 = ((3 - j) * nelt + 2) % 3; 5357 for (i = 0; i < nelt; i++) 5358 { 5359 if (3 * i + nelt0 < nelt) 5360 sel[3 * i + nelt0] = j0++; 5361 if (3 * i + nelt1 < nelt) 5362 sel[3 * i + nelt1] = nelt + j1++; 5363 if (3 * i + nelt2 < nelt) 5364 sel[3 * i + nelt2] = 0; 5365 } 5366 indices.new_vector (sel, 2, nelt); 5367 if (!can_vec_perm_const_p (mode, mode, indices)) 5368 { 5369 if (dump_enabled_p ()) 5370 dump_printf (MSG_MISSED_OPTIMIZATION, 5371 "permutation op not supported by target.\n"); 5372 return false; 5373 } 5374 5375 for (i = 0; i < nelt; i++) 5376 { 5377 if (3 * i + nelt0 < nelt) 5378 sel[3 * i + nelt0] = 3 * i + nelt0; 5379 if (3 * i + nelt1 < nelt) 5380 sel[3 * i + nelt1] = 3 * i + nelt1; 5381 if (3 * i + nelt2 < nelt) 5382 sel[3 * i + nelt2] = nelt + j2++; 5383 } 5384 indices.new_vector (sel, 2, nelt); 5385 if (!can_vec_perm_const_p (mode, mode, indices)) 5386 { 5387 if (dump_enabled_p ()) 5388 dump_printf (MSG_MISSED_OPTIMIZATION, 5389 "permutation op not supported by target.\n"); 5390 return false; 5391 } 5392 } 5393 return true; 5394 } 5395 else 5396 { 5397 /* If length is not equal to 3 then only power of 2 is supported. */ 5398 gcc_assert (pow2p_hwi (count))((void)(!(pow2p_hwi (count)) ? fancy_abort ("/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/tree-vect-data-refs.cc"
, 5398, __FUNCTION__), 0 : 0)); 5399 poly_uint64 nelt = GET_MODE_NUNITS (mode); 5400 5401 /* The encoding has 2 interleaved stepped patterns. */ 5402 vec_perm_builder sel (nelt, 2, 3); 5403 sel.quick_grow (6); 5404 for (i = 0; i < 3; i++) 5405 { 5406 sel[i * 2] = i; 5407 sel[i * 2 + 1] = i + nelt; 5408 } 5409 vec_perm_indices indices (sel, 2, nelt); 5410 if (can_vec_perm_const_p (mode, mode, indices)) 5411 { 5412 for (i = 0; i < 6; i++) 5413 sel[i] += exact_div (nelt, 2); 5414 indices.new_vector (sel, 2, nelt); 5415 if (can_vec_perm_const_p (mode, mode, indices)) 5416 return true; 5417 } 5418 } 5419 } 5420 5421 if (dump_enabled_p ()) 5422 dump_printf (MSG_MISSED_OPTIMIZATION, 5423 "permutation op not supported by target.\n"); 5424 return false; 5425} 5426 5427 5428/* Return TRUE if vec_{mask_}store_lanes is available for COUNT vectors of 5429 type VECTYPE. MASKED_P says whether the masked form is needed. */ 5430 5431bool 5432vect_store_lanes_supported (tree vectype, unsigned HOST_WIDE_INTlong count, 5433 bool masked_p) 5434{ 5435 if (masked_p) 5436 return vect_lanes_optab_supported_p ("vec_mask_store_lanes", 5437 vec_mask_store_lanes_optab, 5438 vectype, count); 5439 else 5440 return vect_lanes_optab_supported_p ("vec_store_lanes", 5441 vec_store_lanes_optab, 5442 vectype, count); 5443} 5444 5445 5446/* Function vect_permute_store_chain. 5447 5448 Given a chain of interleaved stores in DR_CHAIN of LENGTH that must be 5449 a power of 2 or equal to 3, generate interleave_high/low stmts to reorder 5450 the data correctly for the stores. Return the final references for stores 5451 in RESULT_CHAIN. 5452 5453 E.g., LENGTH is 4 and the scalar type is short, i.e., VF is 8. 5454 The input is 4 vectors each containing 8 elements. We assign a number to 5455 each element, the input sequence is: 5456 5457 1st vec: 0 1 2 3 4 5 6 7 5458 2nd vec: 8 9 10 11 12 13 14 15 5459 3rd vec: 16 17 18 19 20 21 22 23 5460 4th vec: 24 25 26 27 28 29 30 31 5461 5462 The output sequence should be: 5463 5464 1st vec: 0 8 16 24 1 9 17 25 5465 2nd vec: 2 10 18 26 3 11 19 27 5466 3rd vec: 4 12 20 28 5 13 21 30 5467 4th vec: 6 14 22 30 7 15 23 31 5468 5469 i.e., we interleave the contents of the four vectors in their order. 5470 5471 We use interleave_high/low instructions to create such output. The input of 5472 each interleave_high/low operation is two vectors: 5473 1st vec 2nd vec 5474 0 1 2 3 4 5 6 7 5475 the even elements of the result vector are obtained left-to-right from the 5476 high/low elements of the first vector. The odd elements of the result are 5477 obtained left-to-right from the high/low elements of the second vector. 5478 The output of interleave_high will be: 0 4 1 5 5479 and of interleave_low: 2 6 3 7 5480 5481 5482 The permutation is done in log LENGTH stages. In each stage interleave_high 5483 and interleave_low stmts are created for each pair of vectors in DR_CHAIN, 5484 where the first argument is taken from the first half of DR_CHAIN and the 5485 second argument from it's second half. 5486 In our example, 5487 5488 I1: interleave_high (1st vec, 3rd vec) 5489 I2: interleave_low (1st vec, 3rd vec) 5490 I3: interleave_high (2nd vec, 4th vec) 5491 I4: interleave_low (2nd vec, 4th vec) 5492 5493 The output for the first stage is: 5494 5495 I1: 0 16 1 17 2 18 3 19 5496 I2: 4 20 5 21 6 22 7 23 5497 I3: 8 24 9 25 10 26 11 27 5498 I4: 12 28 13 29 14 30 15 31 5499 5500 The output of the second stage, i.e. the final result is: 5501 5502 I1: 0 8 16 24 1 9 17 25 5503 I2: 2 10 18 26 3 11 19 27 5504 I3: 4 12 20 28 5 13 21 30 5505 I4: 6 14 22 30 7 15 23 31. */ 5506 5507void 5508vect_permute_store_chain (vec_info *vinfo, vec<tree> &dr_chain, 5509 unsigned int length, 5510 stmt_vec_info stmt_info,