Re: [patch] (un)fix loop unswitching.

[Andrew MacLeod <amacleod at redhat dot com>]

Bah, bounced due to html or something. My latest email client upgrade 
must have lost the 'plain text only' attribute..

On 10/16/2013 08:02 AM, Andrew MacLeod wrote:
> More or less  the same patch that I put in bugzilla 
> http://gcc.gnu.org/bugzilla/show_bug.cgi?id=58697
>
> I've bootstrapped it and run it through regressions.  Jakubs test case 
> fails again like it did before my changes, so it no longer masks the 
> problem.
>
> Loop unswitching was calling estimate_loop_iterations_int, which for 
> various annoying reasons ended up in cfgloop and called 
> get_estimate_loop_iterations, so it wasn't doing the calculations. 
> Hopefully its clearer now.
>
> The end result now is that cfgloop.c has 4  accessor routines which 
> just retrieve info:
> get_estimated_loop_iterations, get_estimated_loop_iterations_int,
> get_max_loop_iterations, and get_max_loop_iterations_int.
>
> tree-ssa-loop-niter.c has 4 routines which create the information 
> first, if they can, then retrieve the information.
> estimated_loop_iterations, estimated_loop_iterations_int,
> max_loop_iterations, and max_loop_iterations_int.
>
> all the cfg*  routines call the 'get_' variety, and all the tree-ssa 
> routines call the non 'get_' variety to calculate things if need be.
>
> Bootstraps on x86_64-unknown-linux-gnu and no regressions. OK? I 
> presume Jakub's test case isn't in the testsuite anywhere then?  I 
> presume it would go in along with a fix to the original problem
>
> Andrew

	* cfgloop.c (get_estimated_loop_iterations_int): Rename from 
	estimated_loop_iterations_int.
	(max_stmt_executions_int): Call get_max_loop_iterations_int.
	(get_max_loop_iterations_int): New.  HWINT version of 
	get_max_loop_iterations.
	* cfgloop.h: Add prototypes.
	* loop-iv.c (find_simple_exit): call get_estimated_loop_iterations_int.
	* loop-unroll.c (decide_peel_once_rolling): Call 
	get_estimated_loop_iterations_int.
	* tree-ssa-loop-niter.c (estimated_loop_iterations_int): Add back.
	* tree-ssa-loop-niter.h: Tweak prototypes.

Index: cfgloop.c
===================================================================
*** cfgloop.c	(revision 203625)
--- cfgloop.c	(working copy)
*************** record_niter_bound (struct loop *loop, d
*** 1815,1826 ****
      loop->nb_iterations_estimate = loop->nb_iterations_upper_bound;
  }
  
! /* Similar to estimated_loop_iterations, but returns the estimate only
     if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
     on the number of iterations of LOOP could not be derived, returns -1.  */
  
  HOST_WIDE_INT
! estimated_loop_iterations_int (struct loop *loop)
  {
    double_int nit;
    HOST_WIDE_INT hwi_nit;
--- 1815,1826 ----
      loop->nb_iterations_estimate = loop->nb_iterations_upper_bound;
  }
  
! /* Similar to get_estimated_loop_iterations, but returns the estimate only
     if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
     on the number of iterations of LOOP could not be derived, returns -1.  */
  
  HOST_WIDE_INT
! get_estimated_loop_iterations_int (struct loop *loop)
  {
    double_int nit;
    HOST_WIDE_INT hwi_nit;
*************** estimated_loop_iterations_int (struct lo
*** 1842,1848 ****
  HOST_WIDE_INT
  max_stmt_executions_int (struct loop *loop)
  {
!   HOST_WIDE_INT nit = max_loop_iterations_int (loop);
    HOST_WIDE_INT snit;
  
    if (nit == -1)
--- 1842,1848 ----
  HOST_WIDE_INT
  max_stmt_executions_int (struct loop *loop)
  {
!   HOST_WIDE_INT nit = get_max_loop_iterations_int (loop);
    HOST_WIDE_INT snit;
  
    if (nit == -1)
*************** get_max_loop_iterations (struct loop *lo
*** 1891,1893 ****
--- 1891,1915 ----
    *nit = loop->nb_iterations_upper_bound;
    return true;
  }
+ 
+ /* Similar to get_max_loop_iterations, but returns the estimate only
+    if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
+    on the number of iterations of LOOP could not be derived, returns -1.  */
+ 
+ HOST_WIDE_INT
+ get_max_loop_iterations_int (struct loop *loop)
+ {
+   double_int nit;
+   HOST_WIDE_INT hwi_nit;
+ 
+   if (!get_max_loop_iterations (loop, &nit))
+     return -1;
+ 
+   if (!nit.fits_shwi ())
+     return -1;
+   hwi_nit = nit.to_shwi ();
+ 
+   return hwi_nit < 0 ? -1 : hwi_nit;
+ }
+ 
+ 
Index: cfgloop.h
===================================================================
*** cfgloop.h	(revision 203625)
--- cfgloop.h	(working copy)
*************** loop_outermost (struct loop *loop)
*** 740,747 ****
  }
  
  extern void record_niter_bound (struct loop *, double_int, bool, bool);
! extern HOST_WIDE_INT estimated_loop_iterations_int (struct loop *);
! extern HOST_WIDE_INT max_loop_iterations_int (struct loop *);
  extern bool get_estimated_loop_iterations (struct loop *loop, double_int *nit);
  extern bool get_max_loop_iterations (struct loop *loop, double_int *nit);
  
--- 740,747 ----
  }
  
  extern void record_niter_bound (struct loop *, double_int, bool, bool);
! extern HOST_WIDE_INT get_estimated_loop_iterations_int (struct loop *);
! extern HOST_WIDE_INT get_max_loop_iterations_int (struct loop *);
  extern bool get_estimated_loop_iterations (struct loop *loop, double_int *nit);
  extern bool get_max_loop_iterations (struct loop *loop, double_int *nit);
  
Index: loop-iv.c
===================================================================
*** loop-iv.c	(revision 203625)
--- loop-iv.c	(working copy)
*************** find_simple_exit (struct loop *loop, str
*** 3001,3009 ****
        	  fprintf (dump_file, "\n");
  
  	  fprintf (dump_file, "  upper bound: %li\n",
! 		   (long)max_loop_iterations_int (loop));
  	  fprintf (dump_file, "  realistic bound: %li\n",
! 		   (long)estimated_loop_iterations_int (loop));
  	}
        else
  	fprintf (dump_file, "Loop %d is not simple.\n", loop->num);
--- 3001,3009 ----
        	  fprintf (dump_file, "\n");
  
  	  fprintf (dump_file, "  upper bound: %li\n",
! 		   (long)get_max_loop_iterations_int (loop));
  	  fprintf (dump_file, "  realistic bound: %li\n",
! 		   (long)get_estimated_loop_iterations_int (loop));
  	}
        else
  	fprintf (dump_file, "Loop %d is not simple.\n", loop->num);
Index: loop-unroll.c
===================================================================
*** loop-unroll.c	(revision 203625)
--- loop-unroll.c	(working copy)
*************** decide_peel_once_rolling (struct loop *l
*** 469,475 ****
        || desc->infinite
        || !desc->const_iter
        || (desc->niter != 0
! 	  && max_loop_iterations_int (loop) != 0))
      {
        if (dump_file)
  	fprintf (dump_file,
--- 469,475 ----
        || desc->infinite
        || !desc->const_iter
        || (desc->niter != 0
! 	  && get_max_loop_iterations_int (loop) != 0))
      {
        if (dump_file)
  	fprintf (dump_file,
Index: loop-unswitch.c
===================================================================
*** loop-unswitch.c	(revision 203625)
--- loop-unswitch.c	(working copy)
*************** unswitch_single_loop (struct loop *loop,
*** 304,310 ****
      }
  
    /* Nor if the loop usually does not roll.  */
!   iterations = estimated_loop_iterations_int (loop);
    if (iterations >= 0 && iterations <= 1)
      {
        if (dump_file)
--- 304,310 ----
      }
  
    /* Nor if the loop usually does not roll.  */
!   iterations = get_estimated_loop_iterations_int (loop);
    if (iterations >= 0 && iterations <= 1)
      {
        if (dump_file)
Index: tree-ssa-loop-niter.c
===================================================================
*** tree-ssa-loop-niter.c	(revision 203625)
--- tree-ssa-loop-niter.c	(working copy)
*************** estimated_loop_iterations (struct loop *
*** 3388,3393 ****
--- 3388,3414 ----
    return (get_estimated_loop_iterations (loop, nit));
  }
  
+ /* Similar to estimated_loop_iterations, but returns the estimate only
+    if it fits to HOST_WIDE_INT.  If this is not the case, or the estimate
+    on the number of iterations of LOOP could not be derived, returns -1.  */
+ 
+ HOST_WIDE_INT
+ estimated_loop_iterations_int (struct loop *loop)
+ {
+   double_int nit;
+   HOST_WIDE_INT hwi_nit;
+ 
+   if (!estimated_loop_iterations (loop, &nit))
+     return -1;
+ 
+   if (!nit.fits_shwi ())
+     return -1;
+   hwi_nit = nit.to_shwi ();
+ 
+   return hwi_nit < 0 ? -1 : hwi_nit;
+ }
+ 
+ 
  /* Sets NIT to an upper bound for the maximum number of executions of the
     latch of the LOOP.  If we have no reliable estimate, the function returns
     false, otherwise returns true.  */
Index: tree-ssa-loop-niter.h
===================================================================
*** tree-ssa-loop-niter.h	(revision 203625)
--- tree-ssa-loop-niter.h	(working copy)
*************** extern bool finite_loop_p (struct loop *
*** 30,36 ****
--- 30,38 ----
  extern tree loop_niter_by_eval (struct loop *, edge);
  extern tree find_loop_niter_by_eval (struct loop *, edge *);
  extern bool estimated_loop_iterations (struct loop *, double_int *);
+ extern HOST_WIDE_INT estimated_loop_iterations_int (struct loop *);
  extern bool max_loop_iterations (struct loop *, double_int *);
+ extern HOST_WIDE_INT max_loop_iterations_int (struct loop *);
  extern HOST_WIDE_INT max_stmt_executions_int (struct loop *);
  extern HOST_WIDE_INT estimated_stmt_executions_int (struct loop *);
  extern bool max_stmt_executions (struct loop *, double_int *);