This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [PATCH] Fix RW dependence testing in vect_analyze_data_ref_dependence
- From: Ira Rosen <IRAR at il dot ibm dot com>
- To: Richard Guenther <rguenther at suse dot de>
- Cc: gcc-patches at gcc dot gnu dot org
- Date: Tue, 13 Apr 2010 09:40:42 +0300
- Subject: Re: [PATCH] Fix RW dependence testing in vect_analyze_data_ref_dependence
- References: <alpine.LNX.2.00.1004121724350.5522@zhemvz.fhfr.qr>
Richard Guenther <rguenther@suse.de> wrote on 12/04/2010 06:28:11 PM:
> 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?
Fine with me.
Thanks,
Ira
>
> 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" } } */
>