This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH] Fix PR59058


This finally fixes PR59058.

Bootstrapped on x86_64-unknown-linux-gnu, testing in progress.

Richard.

2013-12-05  Richard Biener  <rguenther@suse.de>

	PR tree-optimization/59058
	* tree-vectorizer.h (struct _loop_vec_info): Add num_itersm1
	member.
	(LOOP_VINFO_NITERSM1): New macro.
	* tree-vect-loop-manip.c (slpeel_tree_peel_loop_to_edge): Express
	the vector loop entry test in terms of scalar latch executions.
	(vect_do_peeling_for_alignment): Update LOOP_VINFO_NITERSM1.
	* tree-vect-loop.c (vect_get_loop_niters): Also return the
	number of latch executions.
	(new_loop_vec_info): Initialize LOOP_VINFO_NITERSM1.
	(vect_analyze_loop_form): Likewise.
	(vect_generate_tmps_on_preheader): Compute the number of
	vectorized iterations differently.

	* gcc.dg/torture/pr59058.c: New testcase.

Index: trunk/gcc/testsuite/gcc.dg/torture/pr59058.c
===================================================================
*** /dev/null	1970-01-01 00:00:00.000000000 +0000
--- trunk/gcc/testsuite/gcc.dg/torture/pr59058.c	2013-12-05 14:51:54.231300709 +0100
***************
*** 0 ****
--- 1,19 ----
+ /* { dg-do run } */
+ 
+ extern void abort (void);
+ 
+ short b = 0;
+ 
+ int
+ main ()
+ {
+   int c = 0;
+ l1:
+   b++;
+   c |= b;
+   if (b)
+     goto l1;
+   if (c != -1)
+     abort ();
+   return 0;
+ }
Index: trunk/gcc/tree-vect-loop-manip.c
===================================================================
*** trunk.orig/gcc/tree-vect-loop-manip.c	2013-12-05 12:27:23.000000000 +0100
--- trunk/gcc/tree-vect-loop-manip.c	2013-12-05 14:50:59.468666726 +0100
*************** slpeel_tree_peel_loop_to_edge (struct lo
*** 1061,1067 ****
    gimple_stmt_iterator gsi;
    edge exit_e = single_exit (loop);
    source_location loop_loc;
-   tree cost_pre_condition = NULL_TREE;
    /* There are many aspects to how likely the first loop is going to be executed.
       Without histogram we can't really do good job.  Simply set it to
       2/3, so the first loop is not reordered to the end of function and
--- 1061,1066 ----
*************** slpeel_tree_peel_loop_to_edge (struct lo
*** 1263,1283 ****
    /* Epilogue peeling.  */
    if (!update_first_loop_count)
      {
        pre_condition =
! 	fold_build2 (LE_EXPR, boolean_type_node, *first_niters,
! 		     build_int_cst (TREE_TYPE (*first_niters), 0));
!       if (check_profitability)
! 	{
! 	  tree scalar_loop_iters
! 	    = unshare_expr (LOOP_VINFO_NITERS_UNCHANGED
! 					(loop_vec_info_for_loop (loop)));
! 	  cost_pre_condition =
! 	    fold_build2 (LE_EXPR, boolean_type_node, scalar_loop_iters,
! 		         build_int_cst (TREE_TYPE (scalar_loop_iters), th));
! 
! 	  pre_condition = fold_build2 (TRUTH_OR_EXPR, boolean_type_node,
! 				       cost_pre_condition, pre_condition);
! 	}
        if (cond_expr)
  	{
  	  pre_condition =
--- 1262,1278 ----
    /* Epilogue peeling.  */
    if (!update_first_loop_count)
      {
+       loop_vec_info loop_vinfo = loop_vec_info_for_loop (loop);
+       tree scalar_loop_iters = LOOP_VINFO_NITERSM1 (loop_vinfo);
+       unsigned limit = LOOP_VINFO_VECT_FACTOR (loop_vinfo) - 1;
+       if (LOOP_VINFO_PEELING_FOR_GAPS (loop_vinfo))
+ 	limit = limit + 1;
+       if (check_profitability
+ 	  && th > limit)
+ 	limit = th;
        pre_condition =
! 	fold_build2 (LT_EXPR, boolean_type_node, scalar_loop_iters,
! 		     build_int_cst (TREE_TYPE (scalar_loop_iters), limit));
        if (cond_expr)
  	{
  	  pre_condition =
*************** vect_do_peeling_for_alignment (loop_vec_
*** 1922,1927 ****
--- 1917,1925 ----
    /* Update number of times loop executes.  */
    LOOP_VINFO_NITERS (loop_vinfo) = fold_build2 (MINUS_EXPR,
  		TREE_TYPE (ni_name), ni_name, niters_of_prolog_loop);
+   LOOP_VINFO_NITERSM1 (loop_vinfo) = fold_build2 (MINUS_EXPR,
+ 		TREE_TYPE (ni_name),
+ 		LOOP_VINFO_NITERSM1 (loop_vinfo), niters_of_prolog_loop);
  
    if (types_compatible_p (sizetype, TREE_TYPE (niters_of_prolog_loop)))
      wide_prolog_niters = niters_of_prolog_loop;
Index: trunk/gcc/tree-vect-loop.c
===================================================================
*** trunk.orig/gcc/tree-vect-loop.c	2013-12-05 12:27:23.000000000 +0100
--- trunk/gcc/tree-vect-loop.c	2013-12-05 14:36:14.917389587 +0100
*************** vect_analyze_scalar_cycles (loop_vec_inf
*** 791,802 ****
  /* Function vect_get_loop_niters.
  
     Determine how many iterations the loop is executed and place it
!    in NUMBER_OF_ITERATIONS.
  
     Return the loop exit condition.  */
  
  static gimple
! vect_get_loop_niters (struct loop *loop, tree *number_of_iterations)
  {
    tree niters;
  
--- 791,804 ----
  /* Function vect_get_loop_niters.
  
     Determine how many iterations the loop is executed and place it
!    in NUMBER_OF_ITERATIONS.  Place the number of latch iterations
!    in NUMBER_OF_ITERATIONSM1.
  
     Return the loop exit condition.  */
  
  static gimple
! vect_get_loop_niters (struct loop *loop, tree *number_of_iterations,
! 		      tree *number_of_iterationsm1)
  {
    tree niters;
  
*************** vect_get_loop_niters (struct loop *loop,
*** 805,816 ****
  		     "=== get_loop_niters ===\n");
  
    niters = number_of_latch_executions (loop);
    /* We want the number of loop header executions which is the number
       of latch executions plus one.
       ???  For UINT_MAX latch executions this number overflows to zero
       for loops like do { n++; } while (n != 0);  */
    if (niters && !chrec_contains_undetermined (niters))
!     niters = fold_build2 (PLUS_EXPR, TREE_TYPE (niters), niters,
  			  build_int_cst (TREE_TYPE (niters), 1));
    *number_of_iterations = niters;
  
--- 807,820 ----
  		     "=== get_loop_niters ===\n");
  
    niters = number_of_latch_executions (loop);
+   *number_of_iterationsm1 = niters;
+ 
    /* We want the number of loop header executions which is the number
       of latch executions plus one.
       ???  For UINT_MAX latch executions this number overflows to zero
       for loops like do { n++; } while (n != 0);  */
    if (niters && !chrec_contains_undetermined (niters))
!     niters = fold_build2 (PLUS_EXPR, TREE_TYPE (niters), unshare_expr (niters),
  			  build_int_cst (TREE_TYPE (niters), 1));
    *number_of_iterations = niters;
  
*************** new_loop_vec_info (struct loop *loop)
*** 916,921 ****
--- 920,926 ----
     gcc_assert (nbbs == loop->num_nodes);
  
    LOOP_VINFO_BBS (res) = bbs;
+   LOOP_VINFO_NITERSM1 (res) = NULL;
    LOOP_VINFO_NITERS (res) = NULL;
    LOOP_VINFO_NITERS_UNCHANGED (res) = NULL;
    LOOP_VINFO_COST_MODEL_MIN_ITERS (res) = 0;
*************** vect_analyze_loop_form (struct loop *loo
*** 1071,1077 ****
  {
    loop_vec_info loop_vinfo;
    gimple loop_cond;
!   tree number_of_iterations = NULL;
    loop_vec_info inner_loop_vinfo = NULL;
  
    if (dump_enabled_p ())
--- 1076,1082 ----
  {
    loop_vec_info loop_vinfo;
    gimple loop_cond;
!   tree number_of_iterations = NULL, number_of_iterationsm1 = NULL;
    loop_vec_info inner_loop_vinfo = NULL;
  
    if (dump_enabled_p ())
*************** vect_analyze_loop_form (struct loop *loo
*** 1246,1252 ****
  	}
      }
  
!   loop_cond = vect_get_loop_niters (loop, &number_of_iterations);
    if (!loop_cond)
      {
        if (dump_enabled_p ())
--- 1251,1258 ----
  	}
      }
  
!   loop_cond = vect_get_loop_niters (loop, &number_of_iterations,
! 				    &number_of_iterationsm1);
    if (!loop_cond)
      {
        if (dump_enabled_p ())
*************** vect_analyze_loop_form (struct loop *loo
*** 1280,1285 ****
--- 1286,1292 ----
      }
  
    loop_vinfo = new_loop_vec_info (loop);
+   LOOP_VINFO_NITERSM1 (loop_vinfo) = number_of_iterationsm1;
    LOOP_VINFO_NITERS (loop_vinfo) = number_of_iterations;
    LOOP_VINFO_NITERS_UNCHANGED (loop_vinfo) = number_of_iterations;
  
*************** vect_generate_tmps_on_preheader (loop_ve
*** 5637,5648 ****
    tree var;
    tree ratio_name;
    tree ratio_mult_vf_name;
-   tree ni = LOOP_VINFO_NITERS (loop_vinfo);
    int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
    edge pe = loop_preheader_edge (LOOP_VINFO_LOOP (loop_vinfo));
    tree log_vf;
  
!   log_vf = build_int_cst (TREE_TYPE (ni), exact_log2 (vf));
  
    /* If epilogue loop is required because of data accesses with gaps, we
       subtract one iteration from the total number of iterations here for
--- 5644,5654 ----
    tree var;
    tree ratio_name;
    tree ratio_mult_vf_name;
    int vf = LOOP_VINFO_VECT_FACTOR (loop_vinfo);
    edge pe = loop_preheader_edge (LOOP_VINFO_LOOP (loop_vinfo));
    tree log_vf;
  
!   log_vf = build_int_cst (TREE_TYPE (ni_name), exact_log2 (vf));
  
    /* If epilogue loop is required because of data accesses with gaps, we
       subtract one iteration from the total number of iterations here for
*************** vect_generate_tmps_on_preheader (loop_ve
*** 5654,5660 ****
  			               build_one_cst (TREE_TYPE (ni_name)));
        if (!is_gimple_val (ni_minus_gap_name))
  	{
! 	  var = create_tmp_var (TREE_TYPE (ni), "ni_gap");
            gimple stmts = NULL;
            ni_minus_gap_name = force_gimple_operand (ni_minus_gap_name, &stmts,
  						    true, var);
--- 5660,5666 ----
  			               build_one_cst (TREE_TYPE (ni_name)));
        if (!is_gimple_val (ni_minus_gap_name))
  	{
! 	  var = create_tmp_var (TREE_TYPE (ni_name), "ni_gap");
            gimple stmts = NULL;
            ni_minus_gap_name = force_gimple_operand (ni_minus_gap_name, &stmts,
  						    true, var);
*************** vect_generate_tmps_on_preheader (loop_ve
*** 5665,5676 ****
      ni_minus_gap_name = ni_name;
  
    /* Create: ratio = ni >> log2(vf) */
! 
!   ratio_name = fold_build2 (RSHIFT_EXPR, TREE_TYPE (ni_minus_gap_name),
! 			    ni_minus_gap_name, log_vf);
    if (!is_gimple_val (ratio_name))
      {
!       var = create_tmp_var (TREE_TYPE (ni), "bnd");
        gimple stmts = NULL;
        ratio_name = force_gimple_operand (ratio_name, &stmts, true, var);
        gsi_insert_seq_on_edge_immediate (pe, stmts);
--- 5671,5692 ----
      ni_minus_gap_name = ni_name;
  
    /* Create: ratio = ni >> log2(vf) */
!   /* ???  As we have ni == number of latch executions + 1, ni could
!      have overflown to zero.  So avoid computing ratio based on ni
!      but compute it using the fact that we know ratio will be at least
!      one, thus via (ni - vf) >> log2(vf) + 1.  */
!   ratio_name
!     = fold_build2 (PLUS_EXPR, TREE_TYPE (ni_name),
! 		   fold_build2 (RSHIFT_EXPR, TREE_TYPE (ni_name),
! 				fold_build2 (MINUS_EXPR, TREE_TYPE (ni_name),
! 					     ni_minus_gap_name,
! 					     build_int_cst
! 					       (TREE_TYPE (ni_name), vf)),
! 				log_vf),
! 		   build_int_cst (TREE_TYPE (ni_name), 1));
    if (!is_gimple_val (ratio_name))
      {
!       var = create_tmp_var (TREE_TYPE (ni_name), "bnd");
        gimple stmts = NULL;
        ratio_name = force_gimple_operand (ratio_name, &stmts, true, var);
        gsi_insert_seq_on_edge_immediate (pe, stmts);
*************** vect_generate_tmps_on_preheader (loop_ve
*** 5685,5691 ****
  					ratio_name, log_vf);
        if (!is_gimple_val (ratio_mult_vf_name))
  	{
! 	  var = create_tmp_var (TREE_TYPE (ni), "ratio_mult_vf");
  	  gimple stmts = NULL;
  	  ratio_mult_vf_name = force_gimple_operand (ratio_mult_vf_name, &stmts,
  						     true, var);
--- 5701,5707 ----
  					ratio_name, log_vf);
        if (!is_gimple_val (ratio_mult_vf_name))
  	{
! 	  var = create_tmp_var (TREE_TYPE (ni_name), "ratio_mult_vf");
  	  gimple stmts = NULL;
  	  ratio_mult_vf_name = force_gimple_operand (ratio_mult_vf_name, &stmts,
  						     true, var);
Index: trunk/gcc/tree-vectorizer.h
===================================================================
*** trunk.orig/gcc/tree-vectorizer.h	2013-11-28 13:44:24.000000000 +0100
--- trunk/gcc/tree-vectorizer.h	2013-12-05 14:34:07.955901102 +0100
*************** typedef struct _loop_vec_info {
*** 250,257 ****
--- 250,260 ----
    /* The loop basic blocks.  */
    basic_block *bbs;
  
+   /* Number of latch executions.  */
+   tree num_itersm1;
    /* Number of iterations.  */
    tree num_iters;
+   /* Number of iterations of the original loop.  */
    tree num_iters_unchanged;
  
    /* Minimum number of iterations below which vectorization is expected to
*************** typedef struct _loop_vec_info {
*** 349,357 ****
  /* Access Functions.  */
  #define LOOP_VINFO_LOOP(L)                 (L)->loop
  #define LOOP_VINFO_BBS(L)                  (L)->bbs
  #define LOOP_VINFO_NITERS(L)               (L)->num_iters
! /* Since LOOP_VINFO_NITERS can change after prologue peeling
!    retain total unchanged scalar loop iterations for cost model.  */
  #define LOOP_VINFO_NITERS_UNCHANGED(L)     (L)->num_iters_unchanged
  #define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters
  #define LOOP_VINFO_VECTORIZABLE_P(L)       (L)->vectorizable
--- 352,362 ----
  /* Access Functions.  */
  #define LOOP_VINFO_LOOP(L)                 (L)->loop
  #define LOOP_VINFO_BBS(L)                  (L)->bbs
+ #define LOOP_VINFO_NITERSM1(L)             (L)->num_itersm1
  #define LOOP_VINFO_NITERS(L)               (L)->num_iters
! /* Since LOOP_VINFO_NITERS and LOOP_VINFO_NITERSM1 can change after
!    prologue peeling retain total unchanged scalar loop iterations for
!    cost model.  */
  #define LOOP_VINFO_NITERS_UNCHANGED(L)     (L)->num_iters_unchanged
  #define LOOP_VINFO_COST_MODEL_MIN_ITERS(L) (L)->min_profitable_iters
  #define LOOP_VINFO_VECTORIZABLE_P(L)       (L)->vectorizable


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]