[PATCH] Fix RW dependence testing in vect_analyze_data_ref_dependence
Richard Guenther
rguenther@suse.de
Mon Apr 12 15:28:00 GMT 2010
This splits out a piece of my patches to allow multiple vector sizes
in the vectorizer for AVX benefit. I tried to just split out
* tree-vect-data-refs.c (vect_analyze_data_ref_dependence):
Only add RW dependence for dependence distance zero.
but that drew in a whole lot of stuff. Namely the following - mostly
caused by the need to interchange dependence and alingment analyses
and to handle some of it before determining the vectorization factor.
Thus, it has the chance of shrinking the final patch - which is IMHO
good.
Bootstrapped and tested on x86_64-unknown-linux-gnu, ok for trunk?
Thanks,
Richard.
2010-04-12 Richard Guenther <rguenther@suse.de>
* tree-vect-data-refs.c (vect_analyze_data_ref_dependence):
Only add RW dependence for dependence distance zero.
Adjust maximal vectorization factor according to dependences.
Move alignment handling ...
(vect_find_same_alignment_drs): ... here. New function.
(vect_analyze_data_ref_dependences): Adjust.
(vect_analyze_data_refs_alignment): Call vect_find_same_alignment_drs.
(vect_analyze_data_refs): Adjust minimal vectorization factor
according to data references.
* tree-vect-loop.c (vect_analyze_loop): Analyze data-ref
dependences before determining the vectorization factor.
Analyze alignment after determining the vectorization factor.
* tree-vect-slp.c ((vect_slp_analyze_bb): Analyze data-ref
dependences before alignment.
* tree-vectorizer.h (vect_analyze_data_ref_dependences):
Adjust prototype.
(vect_analyze_data_refs): Likewise.
(MAX_VECTORIZATION_FACTOR): New define.
* gcc.dg/vect/no-vfa-vect-depend-1.c: Adjust.
Index: trunk/gcc/tree-vect-data-refs.c
===================================================================
*** trunk.orig/gcc/tree-vect-data-refs.c 2010-04-12 15:30:11.000000000 +0200
--- trunk/gcc/tree-vect-data-refs.c 2010-04-12 15:38:10.000000000 +0200
*************** vect_mark_for_runtime_alias_test (ddr_p
*** 487,507 ****
Return TRUE 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 FALSE. */
static bool
vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr,
! loop_vec_info loop_vinfo)
{
unsigned int i;
struct loop *loop = NULL;
- int vectorization_factor = 0;
struct data_reference *dra = DDR_A (ddr);
struct data_reference *drb = DDR_B (ddr);
stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra));
stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb));
- int dra_size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (DR_REF (dra))));
- int drb_size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (DR_REF (drb))));
lambda_vector dist_v;
unsigned int loop_depth;
--- 487,505 ----
Return TRUE 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 FALSE. Adjust *MAX_VF according to
! the data dependence. */
static bool
vect_analyze_data_ref_dependence (struct data_dependence_relation *ddr,
! loop_vec_info loop_vinfo, int *max_vf)
{
unsigned int i;
struct loop *loop = NULL;
struct data_reference *dra = DDR_A (ddr);
struct data_reference *drb = DDR_B (ddr);
stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra));
stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb));
lambda_vector dist_v;
unsigned int loop_depth;
*************** vect_analyze_data_ref_dependence (struct
*** 513,522 ****
}
if (loop_vinfo)
! {
! loop = LOOP_VINFO_LOOP (loop_vinfo);
! vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
! }
if ((DR_IS_READ (dra) && DR_IS_READ (drb) && loop_vinfo) || dra == drb)
return false;
--- 511,517 ----
}
if (loop_vinfo)
! loop = LOOP_VINFO_LOOP (loop_vinfo);
if ((DR_IS_READ (dra) && DR_IS_READ (drb) && loop_vinfo) || dra == drb)
return false;
*************** vect_analyze_data_ref_dependence (struct
*** 595,611 ****
if (vect_print_dump_info (REPORT_DR_DETAILS))
fprintf (vect_dump, "dependence distance = %d.", dist);
! /* Same loop iteration. */
! if (dist % vectorization_factor == 0 && dra_size == drb_size)
{
- /* Two references with distance zero have the same alignment. */
- VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_a), drb);
- VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_b), dra);
- if (vect_print_dump_info (REPORT_ALIGNMENT))
- fprintf (vect_dump, "accesses have the same alignment.");
if (vect_print_dump_info (REPORT_DR_DETAILS))
{
! fprintf (vect_dump, "dependence distance modulo vf == 0 between ");
print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
fprintf (vect_dump, " and ");
print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
--- 590,600 ----
if (vect_print_dump_info (REPORT_DR_DETAILS))
fprintf (vect_dump, "dependence distance = %d.", dist);
! if (dist == 0)
{
if (vect_print_dump_info (REPORT_DR_DETAILS))
{
! fprintf (vect_dump, "dependence distance == 0 between ");
print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
fprintf (vect_dump, " and ");
print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
*************** vect_analyze_data_ref_dependence (struct
*** 621,638 ****
DR_GROUP_READ_WRITE_DEPENDENCE (stmtinfo_b) = true;
}
! continue;
}
! if (abs (dist) >= vectorization_factor
! || (dist > 0 && DDR_REVERSED_P (ddr)))
{
/* Dependence distance does not create dependence, as far as
! vectorization is concerned, in this case. 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 (vect_print_dump_info (REPORT_DR_DETAILS))
! fprintf (vect_dump, "dependence distance >= VF or negative.");
continue;
}
--- 610,645 ----
DR_GROUP_READ_WRITE_DEPENDENCE (stmtinfo_b) = true;
}
! continue;
! }
!
! if (dist > 0 && DDR_REVERSED_P (ddr))
! {
! /* 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 (vect_print_dump_info (REPORT_DR_DETAILS))
! fprintf (vect_dump, "dependence distance negative.");
! continue;
! }
!
! if (abs (dist) >= 2
! && abs (dist) < *max_vf)
! {
! /* The dependence distance requires reduction of the maximal
! vectorization factor. */
! *max_vf = abs (dist);
! if (vect_print_dump_info (REPORT_DR_DETAILS))
! fprintf (vect_dump, "adjusting maximal vectorization factor to %i",
! *max_vf);
}
! if (abs (dist) >= *max_vf)
{
/* Dependence distance does not create dependence, as far as
! vectorization is concerned, in this case. */
if (vect_print_dump_info (REPORT_DR_DETAILS))
! fprintf (vect_dump, "dependence distance >= VF.");
continue;
}
*************** vect_analyze_data_ref_dependence (struct
*** 654,664 ****
/* 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. */
bool
vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo,
! bb_vec_info bb_vinfo)
{
unsigned int i;
VEC (ddr_p, heap) *ddrs = NULL;
--- 661,672 ----
/* 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. */
bool
vect_analyze_data_ref_dependences (loop_vec_info loop_vinfo,
! bb_vec_info bb_vinfo, int *max_vf)
{
unsigned int i;
VEC (ddr_p, heap) *ddrs = NULL;
*************** vect_analyze_data_ref_dependences (loop_
*** 673,679 ****
ddrs = BB_VINFO_DDRS (bb_vinfo);
for (i = 0; VEC_iterate (ddr_p, ddrs, i, ddr); i++)
! if (vect_analyze_data_ref_dependence (ddr, loop_vinfo))
return false;
return true;
--- 681,687 ----
ddrs = BB_VINFO_DDRS (bb_vinfo);
for (i = 0; VEC_iterate (ddr_p, ddrs, i, ddr); i++)
! if (vect_analyze_data_ref_dependence (ddr, loop_vinfo, max_vf))
return false;
return true;
*************** vect_enhance_data_refs_alignment (loop_v
*** 1410,1415 ****
--- 1418,1486 ----
}
+ /* Function vect_find_same_alignment_drs.
+
+ Update group and alignment relations according to the chosen
+ vectorization factor. */
+
+ static void
+ vect_find_same_alignment_drs (struct data_dependence_relation *ddr,
+ loop_vec_info loop_vinfo)
+ {
+ unsigned int i;
+ struct loop *loop = LOOP_VINFO_LOOP (loop_vinfo);
+ int vectorization_factor = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
+ struct data_reference *dra = DDR_A (ddr);
+ struct data_reference *drb = DDR_B (ddr);
+ stmt_vec_info stmtinfo_a = vinfo_for_stmt (DR_STMT (dra));
+ stmt_vec_info stmtinfo_b = vinfo_for_stmt (DR_STMT (drb));
+ int dra_size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (DR_REF (dra))));
+ int drb_size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (DR_REF (drb))));
+ lambda_vector dist_v;
+ unsigned int loop_depth;
+
+ if (DDR_ARE_DEPENDENT (ddr) == chrec_known)
+ return;
+
+ if ((DR_IS_READ (dra) && DR_IS_READ (drb)) || dra == drb)
+ return;
+
+ if (DDR_ARE_DEPENDENT (ddr) == chrec_dont_know)
+ return;
+
+ /* Loop-based vectorization and known data dependence. */
+ if (DDR_NUM_DIST_VECTS (ddr) == 0)
+ return;
+
+ loop_depth = index_in_loop_nest (loop->num, DDR_LOOP_NEST (ddr));
+ for (i = 0; VEC_iterate (lambda_vector, DDR_DIST_VECTS (ddr), i, dist_v); i++)
+ {
+ int dist = dist_v[loop_depth];
+
+ if (vect_print_dump_info (REPORT_DR_DETAILS))
+ fprintf (vect_dump, "dependence distance = %d.", dist);
+
+ /* Same loop iteration. */
+ if (dist == 0
+ || (dist % vectorization_factor == 0 && dra_size == drb_size))
+ {
+ /* Two references with distance zero have the same alignment. */
+ VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_a), drb);
+ VEC_safe_push (dr_p, heap, STMT_VINFO_SAME_ALIGN_REFS (stmtinfo_b), dra);
+ if (vect_print_dump_info (REPORT_ALIGNMENT))
+ fprintf (vect_dump, "accesses have the same alignment.");
+ if (vect_print_dump_info (REPORT_DR_DETAILS))
+ {
+ fprintf (vect_dump, "dependence distance modulo vf == 0 between ");
+ print_generic_expr (vect_dump, DR_REF (dra), TDF_SLIM);
+ fprintf (vect_dump, " and ");
+ print_generic_expr (vect_dump, DR_REF (drb), TDF_SLIM);
+ }
+ }
+ }
+ }
+
+
/* Function vect_analyze_data_refs_alignment
Analyze the alignment of the data-references in the loop.
*************** vect_analyze_data_refs_alignment (loop_v
*** 1422,1427 ****
--- 1493,1510 ----
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "=== vect_analyze_data_refs_alignment ===");
+ /* Mark groups of data references with same alignment using
+ data dependence information. */
+ if (loop_vinfo)
+ {
+ VEC (ddr_p, heap) *ddrs = LOOP_VINFO_DDRS (loop_vinfo);
+ struct data_dependence_relation *ddr;
+ unsigned int i;
+
+ for (i = 0; VEC_iterate (ddr_p, ddrs, i, ddr); i++)
+ vect_find_same_alignment_drs (ddr, loop_vinfo);
+ }
+
if (!vect_compute_data_refs_alignment (loop_vinfo, bb_vinfo))
{
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
*************** vect_prune_runtime_alias_test_list (loop
*** 1852,1858 ****
*/
bool
! vect_analyze_data_refs (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo)
{
struct loop *loop = NULL;
basic_block bb = NULL;
--- 1935,1943 ----
*/
bool
! vect_analyze_data_refs (loop_vec_info loop_vinfo,
! bb_vec_info bb_vinfo,
! int *min_vf)
{
struct loop *loop = NULL;
basic_block bb = NULL;
*************** vect_analyze_data_refs (loop_vec_info lo
*** 1907,1912 ****
--- 1992,1998 ----
gimple stmt;
stmt_vec_info stmt_info;
tree base, offset, init;
+ int vf;
if (!dr || !DR_REF (dr))
{
*************** vect_analyze_data_refs (loop_vec_info lo
*** 2079,2084 ****
--- 2165,2176 ----
}
return false;
}
+
+ /* Adjust the minimal vectorization factor according to the
+ vector type. */
+ vf = TYPE_VECTOR_SUBPARTS (STMT_VINFO_VECTYPE (stmt_info));
+ if (vf > *min_vf)
+ *min_vf = vf;
}
return true;
Index: trunk/gcc/tree-vect-loop.c
===================================================================
*** trunk.orig/gcc/tree-vect-loop.c 2010-04-12 15:30:11.000000000 +0200
--- trunk/gcc/tree-vect-loop.c 2010-04-12 15:37:42.000000000 +0200
*************** vect_analyze_loop (struct loop *loop)
*** 1354,1359 ****
--- 1354,1361 ----
{
bool ok;
loop_vec_info loop_vinfo;
+ int max_vf = MAX_VECTORIZATION_FACTOR;
+ int min_vf = 2;
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "===== analyze_loop_nest =====");
*************** vect_analyze_loop (struct loop *loop)
*** 1378,1389 ****
}
/* Find all data references in the loop (which correspond to vdefs/vuses)
! and analyze their evolution in the loop.
FORNOW: Handle only simple, array references, which
alignment can be forced, and aligned pointer-references. */
! ok = vect_analyze_data_refs (loop_vinfo, NULL);
if (!ok)
{
if (vect_print_dump_info (REPORT_DETAILS))
--- 1380,1392 ----
}
/* Find all data references in the loop (which correspond to vdefs/vuses)
! and analyze their evolution in the loop. Also adjust the minimal
! vectorization factor according to the loads and stores.
FORNOW: Handle only simple, array references, which
alignment can be forced, and aligned pointer-references. */
! ok = vect_analyze_data_refs (loop_vinfo, NULL, &min_vf);
if (!ok)
{
if (vect_print_dump_info (REPORT_DETAILS))
*************** vect_analyze_loop (struct loop *loop)
*** 1410,1423 ****
return NULL;
}
! /* Analyze the alignment of the data-refs in the loop.
! Fail if a data reference is found that cannot be vectorized. */
! ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
! if (!ok)
{
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "bad data alignment.");
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
--- 1413,1429 ----
return NULL;
}
! /* Analyze data dependences between the data-refs in the loop
! and adjust the maximum vectorization factor according to
! the dependences.
! FORNOW: fail at the first data dependence that we encounter. */
! ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL, &max_vf);
! if (!ok
! || max_vf < min_vf)
{
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "bad data dependence.");
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
*************** vect_analyze_loop (struct loop *loop)
*** 1430,1444 ****
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
! /* Analyze data dependences between the data-refs in the loop.
! FORNOW: fail at the first data dependence that we encounter. */
! ok = vect_analyze_data_ref_dependences (loop_vinfo, NULL);
if (!ok)
{
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "bad data dependence.");
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
--- 1436,1457 ----
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
+ if (max_vf < LOOP_VINFO_VECT_FACTOR (loop_vinfo))
+ {
+ if (vect_print_dump_info (REPORT_DETAILS))
+ fprintf (vect_dump, "bad data dependence.");
+ destroy_loop_vec_info (loop_vinfo, true);
+ return NULL;
+ }
! /* Analyze the alignment of the data-refs in the loop.
! Fail if a data reference is found that cannot be vectorized. */
! ok = vect_analyze_data_refs_alignment (loop_vinfo, NULL);
if (!ok)
{
if (vect_print_dump_info (REPORT_DETAILS))
! fprintf (vect_dump, "bad data alignment.");
destroy_loop_vec_info (loop_vinfo, true);
return NULL;
}
Index: trunk/gcc/tree-vect-slp.c
===================================================================
*** trunk.orig/gcc/tree-vect-slp.c 2010-04-12 15:30:11.000000000 +0200
--- trunk/gcc/tree-vect-slp.c 2010-04-12 15:37:42.000000000 +0200
*************** vect_slp_analyze_bb (basic_block bb)
*** 1270,1275 ****
--- 1270,1277 ----
slp_instance instance;
int i, insns = 0;
gimple_stmt_iterator gsi;
+ int min_vf = 2;
+ int max_vf = MAX_VECTORIZATION_FACTOR;
if (vect_print_dump_info (REPORT_DETAILS))
fprintf (vect_dump, "===vect_slp_analyze_bb===\n");
*************** vect_slp_analyze_bb (basic_block bb)
*** 1296,1302 ****
if (!bb_vinfo)
return NULL;
! if (!vect_analyze_data_refs (NULL, bb_vinfo))
{
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
fprintf (vect_dump, "not vectorized: unhandled data-ref in basic "
--- 1298,1304 ----
if (!bb_vinfo)
return NULL;
! if (!vect_analyze_data_refs (NULL, bb_vinfo, &min_vf))
{
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
fprintf (vect_dump, "not vectorized: unhandled data-ref in basic "
*************** vect_slp_analyze_bb (basic_block bb)
*** 1317,1322 ****
--- 1319,1335 ----
return NULL;
}
+ if (!vect_analyze_data_ref_dependences (NULL, bb_vinfo, &max_vf)
+ || min_vf > max_vf)
+ {
+ if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
+ fprintf (vect_dump, "not vectorized: unhandled data dependence "
+ "in basic block.\n");
+
+ destroy_bb_vec_info (bb_vinfo);
+ return NULL;
+ }
+
if (!vect_analyze_data_refs_alignment (NULL, bb_vinfo))
{
if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
*************** vect_slp_analyze_bb (basic_block bb)
*** 1325,1340 ****
destroy_bb_vec_info (bb_vinfo);
return NULL;
- }
-
- if (!vect_analyze_data_ref_dependences (NULL, bb_vinfo))
- {
- if (vect_print_dump_info (REPORT_UNVECTORIZED_LOCATIONS))
- fprintf (vect_dump, "not vectorized: unhandled data dependence in basic"
- " block.\n");
-
- destroy_bb_vec_info (bb_vinfo);
- return NULL;
}
if (!vect_analyze_data_ref_accesses (NULL, bb_vinfo))
--- 1338,1343 ----
Index: trunk/gcc/tree-vectorizer.h
===================================================================
*** trunk.orig/gcc/tree-vectorizer.h 2010-04-12 15:30:11.000000000 +0200
--- trunk/gcc/tree-vectorizer.h 2010-04-12 15:37:42.000000000 +0200
*************** typedef struct _stmt_vec_info {
*** 601,606 ****
--- 601,609 ----
conversion. */
#define MAX_INTERM_CVT_STEPS 3
+ /* The maximum vectorization factor supported by any target (V32QI). */
+ #define MAX_VECTORIZATION_FACTOR 32
+
/* Avoid GTY(()) on stmt_vec_info. */
typedef void *vec_void_p;
DEF_VEC_P (vec_void_p);
*************** extern enum dr_alignment_support vect_su
*** 802,814 ****
(struct data_reference *);
extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
HOST_WIDE_INT *);
! extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info);
extern bool vect_enhance_data_refs_alignment (loop_vec_info);
extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
! extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info);
extern tree vect_create_data_ref_ptr (gimple, struct loop *, tree, tree *,
gimple *, bool, bool *);
extern tree bump_vector_ptr (tree, gimple, gimple_stmt_iterator *, gimple, tree);
--- 805,818 ----
(struct data_reference *);
extern tree vect_get_smallest_scalar_type (gimple, HOST_WIDE_INT *,
HOST_WIDE_INT *);
! extern bool vect_analyze_data_ref_dependences (loop_vec_info, bb_vec_info,
! int *);
extern bool vect_enhance_data_refs_alignment (loop_vec_info);
extern bool vect_analyze_data_refs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_verify_datarefs_alignment (loop_vec_info, bb_vec_info);
extern bool vect_analyze_data_ref_accesses (loop_vec_info, bb_vec_info);
extern bool vect_prune_runtime_alias_test_list (loop_vec_info);
! extern bool vect_analyze_data_refs (loop_vec_info, bb_vec_info, int *);
extern tree vect_create_data_ref_ptr (gimple, struct loop *, tree, tree *,
gimple *, bool, bool *);
extern tree bump_vector_ptr (tree, gimple, gimple_stmt_iterator *, gimple, tree);
Index: trunk/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c
===================================================================
*** trunk.orig/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c 2010-04-12 15:35:11.000000000 +0200
--- trunk/gcc/testsuite/gcc.dg/vect/no-vfa-vect-depend-1.c 2010-04-12 15:37:42.000000000 +0200
*************** int main (void)
*** 51,56 ****
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {xfail vect_no_align } } } */
! /* { dg-final { scan-tree-dump-times "dependence distance >= VF or negative" 1 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
--- 51,56 ----
}
/* { dg-final { scan-tree-dump-times "vectorized 1 loops" 1 "vect" {xfail vect_no_align } } } */
! /* { dg-final { scan-tree-dump-times "dependence distance negative" 1 "vect" } } */
/* { dg-final { cleanup-tree-dump "vect" } } */
More information about the Gcc-patches
mailing list