public inbox for gcc-bugs@sourceware.org
help / color / mirror / Atom feed
[parent not found: <bug-22586-280@http.gcc.gnu.org/bugzilla/>]
* [Bug tree-optimization/22586] New: GVN-PRE could do strength reduction
@ 2005-07-21 12:11 steven at gcc dot gnu dot org
  2005-07-21 16:18 ` [Bug tree-optimization/22586] " pinskia at gcc dot gnu dot org
  0 siblings, 1 reply; 5+ messages in thread
From: steven at gcc dot gnu dot org @ 2005-07-21 12:11 UTC (permalink / raw)
  To: gcc-bugs

There doesn't appear to be any reason why GVN-PRE couldn't be extended to 
do strength reduction.  If this is added, the strength reduction currently 
done in DOM and IVOPTS may be removed or simplified.  The implementation in 
IVOPTS only works on loops, and the transformations done in DOM only works 
in a few special cases and only on a branch of the dominator tree (i.e. not 
a global pass). 
 
Also, GVN-PRE could replace the flag_unsafe_math_optimizations trick that 
used to be in expr.c and is now in tree-ssa-loop-im.c: 
 
      /* If divisor is invariant, convert a/b to a*(1/b), allowing reciprocal 
         to be hoisted out of loop, saving expensive divide.  */ 
 
Adding this transformation as a special case of "strength reduction" to 
GVN-PRE would allow the transformation to be done on straight-line code as 
well (the code in expr.c used to do this, but we don't do the transformation 
anymore at the moment). 
 
Consider as an example: 
 
int 
foo (int a[], int b[], int i) 
{ 
  a[i] = b[i] + 2; 
  i++; 
  a[i] = b[i] + 2; 
  i++; 
  a[i] = b[i] + 2; 
  i++; 
  a[i] = b[i] + 2; 
  i++; 
  return i; 
} 
 
"GCC 4.1.0 20050721 (experimental)" produces the following .vars dump: 
 
foo (a, b, i) 
{ 
  int * temp.44; 
  int * temp.43; 
  int * temp.42; 
  int * D.1608; 
 
<bb 0>: 
  D.1608 = (int *) ((long unsigned int) i * 4); 
  *(D.1608 + a) = *(D.1608 + b) + 2; 
  temp.42 = (int *) ((long unsigned int) (i + 1) * 4); 
  *(a + temp.42) = *(b + temp.42) + 2; 
  temp.43 = (int *) ((long unsigned int) (i + 2) * 4); 
  *(a + temp.43) = *(b + temp.43) + 2; 
  temp.44 = (int *) ((long unsigned int) (i + 3) * 4); 
  *(a + temp.44) = *(b + temp.44) + 2; 
  return i + 4; 
 
} 
 
Note the redundant computations of "i*4".  Indeed, we don't optimize these 
away on RTL either.

-- 
           Summary: GVN-PRE could do strength reduction
           Product: gcc
           Version: 4.1.0
            Status: UNCONFIRMED
          Keywords: missed-optimization, TREE
          Severity: enhancement
          Priority: P3
         Component: tree-optimization
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: steven at gcc dot gnu dot org
                CC: dberlin at gcc dot gnu dot org,gcc-bugs at gcc dot gnu
                    dot org


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=22586


^ permalink raw reply	[flat|nested] 5+ messages in thread
end of thread, other threads:[~2012-06-28  1:29 UTC | newest]

Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
     [not found] <bug-22586-4@http.gcc.gnu.org/bugzilla/>
2012-03-04  0:00 ` [Bug tree-optimization/22586] GVN-PRE could do strength reduction pinskia at gcc dot gnu.org
2012-03-05  5:33 ` pinskia at gcc dot gnu.org
2012-06-28  1:29 ` wschmidt at gcc dot gnu.org
     [not found] <bug-22586-280@http.gcc.gnu.org/bugzilla/>
2008-02-23  5:27 ` pinskia at gcc dot gnu dot org
2005-07-21 12:11 [Bug tree-optimization/22586] New: " steven at gcc dot gnu dot org
2005-07-21 16:18 ` [Bug tree-optimization/22586] " pinskia at gcc dot gnu dot org

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).