[Bug middle-end/64225] New: -funsafe-math-optimizations generates call to pow where multiply instruction would do

[Bug middle-end/64225] New: -funsafe-math-optimizations generates call to pow where multiply instruction would do

[bernie.ogden at linaro dot org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

            Bug ID: 64225
           Summary: -funsafe-math-optimizations generates call to pow
                    where multiply instruction would do
           Product: gcc
           Version: 4.9.2
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: middle-end
          Assignee: unassigned at gcc dot gnu.org
          Reporter: bernie.ogden at linaro dot org

Created attachment 34217
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=34217&action=edit
Reproducer

Running e.g.
./gcc-linaro-aarch64-linux-gnu-4.9-2014.09_linux/bin/aarch64-linux-gnu-gcc -S
-o - r.i -O1 -funsafe-math-optimizations generates code like this:

stp    x29, x30, [sp, -32]!
add    x29, sp, 0
str    d8, [sp, 16]
fmov    d8, d0
fmov    d1, 2.0e+0
bl    pow
fmul    d8, d8, d8
ldr    d0, .LC0
fmul    d0, d8, d0
ldr    d8, [sp, 16]
ldp    x29, x30, [sp], 32
ret

Removing -funsafe-math-optimizations, or replacing it with -ffast-math,
replaces the call to pow with the intuitively more sensible fmul and saves the
stacking, e.g.:

ldr    d1, .LC0
fmul    d1, d0, d1
fmul    d0, d1, d0
ret


A little experimentation shows similar behaviour for AArch32, AArch64 and x86.
By binary chopping through Linaro releases I find the behaviour begins with the
first 4.8 release (gcc version 4.8.1 20130401 (prerelease)).

Attached r.i and the output generated by:
./gcc-linaro-aarch64-linux-gnu-4.9-2014.09_linux/bin/aarch64-linux-gnu-gcc -v
--save-temps -S -o - r.c -O1 -funsafe-math-optimizations > output 2>&1

Guessed middle-end for Component, and entered latest version in which I've seen
the bug for Version.

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[bernie.ogden at linaro dot org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #1 from Bernard Ogden <bernie.ogden at linaro dot org> ---
Created attachment 34218
  --> https://gcc.gnu.org/bugzilla/attachment.cgi?id=34218&action=edit
-v output

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[ktkachov at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

ktkachov at gcc dot gnu.org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |ktkachov at gcc dot gnu.org

--- Comment #2 from ktkachov at gcc dot gnu.org ---
(In reply to Bernard Ogden from comment #1)
> Created attachment 34218 [details]
> -v output

Hmm, I get the good sequence:
        ldr     d1, .LC0
        fmul    d1, d0, d1
        fmul    d0, d1, d0

with current FSF 4.8.4, 4.9.3 and latest 5.0 with just -O1 without having to
specify -funsafe-math-optimisations or -ffast-math

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[ktkachov at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

ktkachov at gcc dot gnu.org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2014-12-08
     Ever confirmed|0                           |1

--- Comment #3 from ktkachov at gcc dot gnu.org ---
(In reply to ktkachov from comment #2)
> (In reply to Bernard Ogden from comment #1)
> > Created attachment 34218 [details]
> > -v output
> 
> Hmm, I get the good sequence:
>         ldr     d1, .LC0
>         fmul    d1, d0, d1
>         fmul    d0, d1, d0
> 
> with current FSF 4.8.4, 4.9.3 and latest 5.0 with just -O1 without having to
> specify -funsafe-math-optimisations or -ffast-math

Ah wait, sorry, I misread the report. The problem is that
-funsafe-math-optimisations introduces that call to pow instead of doing the
mults.

Confirmed.

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[ktkachov at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #4 from ktkachov at gcc dot gnu.org ---
Add -fno-math-errno removes the call to pow. We've seen similar issues before
with other math builtins. The problem is that the midend/frontend generates the
pow call without remembering that by doing so it should assume that the
multiplication cannot set errno

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[jgreenhalgh at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #5 from jgreenhalgh at gcc dot gnu.org ---
I've seen similar behavior on an HPC benchmark I was looking at.

The problem here is the interaction between fold-const.c, other passes, and
-fmath-errno.

Take this testcase:

void
foo (double x)
{
  x * x;
}

fold-const.c is going to see x *x and canonicalize it to a call to pow. No
other pass will want to touch it, because now it could set errno, so we get as
code generation:

foo:
    fmov    d1, 2.0e+0
    b    pow


If we add -fno-math-errno :

foo:
    ret

When I looked at this before I convinced myself that fold-const.c shouldn't be
doing the canonicalization to pow if we cared about errno - but I never spun a
patch for it - and I'm not sure I'm right.

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[ktkachov at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #6 from ktkachov at gcc dot gnu.org ---
fold-const.c has a comment in the relevant case that says:
 /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x.  */

So we should look at why is it not being expanded as such unless
-fno-math-errno

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[joseph at codesourcery dot com]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #8 from joseph at codesourcery dot com <joseph at codesourcery dot com> ---
Expanding x * x (or any such multiplication) to a call to pow is 
inherently dubious because the semantics of multiplication never include 
clobbering errno, though maybe it's OK with -funsafe-math-optimizations to 
introduce such a clobber.

I think it would be useful to have no-errno-setting-needed versions of 
libm function builtins that users can call explicitly, as well as for 
internal use by GCC when it generates a built-in function call from code 
that doesn't set errno.

(For example: glibc uses __builtin_fma to expand to an fma instruction 
when _FP_FAST_FMA indicates one is available.  But strictly it's incorrect 
to expand fma / __builtin_fma calls to such an instruction without 
considering errno, unless -fno-math-errno.  None of those glibc uses 
require fma to set errno (and glibc fma has its own bug where it fails to 
do so), so it would be beneficial to have __builtin_fma_noerrno to reflect 
what's actually required - this function would expand inline if possible, 
and failing that would call an fma function that might or might not end up 
settting errno.)

[Bug middle-end/64225] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |wschmidt at gcc dot gnu.org

--- Comment #9 from Richard Biener <rguenth at gcc dot gnu.org> ---
(In reply to ktkachov from comment #7)
> (In reply to ktkachov from comment #6)
> > fold-const.c has a comment in the relevant case that says:
> >  /* Canonicalize x*x as pow(x,2.0), which is expanded as x*x.  */
> 
> I think this comment is misleading.
> In builtins.c the expand_builtin_mathfn_2 handles the expansion of pow and I
> don't see any code to expand pow (x, 2.0) as x * x. It tries to use the pow
> optab, so unless the backend explicitly expands the case in such a manner,
> it will not be converted to x*x.
> 
> Is there some other place in the compiler that plays a role here?

The sincos pass in tree-ssa-math-opts.c expands pow with integer exponent
to an optimal multiplication sequence.

But this is just guarded with flag_unsafe_math_optimizations, so I don't
see where you get the -fmath-errno issue.  In fact I can reproduce the issue
on x86_64-linux and the issue is that reassociation creates powi (d, 2)
but does not remove the original pow call which ends up not being DCEd
because of the errno setting.

CCing author.

The simplest patch would be to reject the transform with -fmath-errno like
with (pre-approved)

Index: gcc/tree-ssa-reassoc.c
===================================================================
--- gcc/tree-ssa-reassoc.c      (revision 218479)
+++ gcc/tree-ssa-reassoc.c      (working copy)
@@ -3988,6 +3988,9 @@ acceptable_pow_call (gimple stmt, tree *
   switch (DECL_FUNCTION_CODE (fndecl))
     {
     CASE_FLT_FN (BUILT_IN_POW):
+      if (flag_errno_math)
+        return false;
+
       *base = gimple_call_arg (stmt, 0);
       arg1 = gimple_call_arg (stmt, 1);

[Bug middle-end/64225] [4.8/4.9/5 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to work|                            |4.7.4
   Target Milestone|---                         |4.8.4
            Summary|-funsafe-math-optimizations |[4.8/4.9/5 Regression]
                   |generates call to pow where |-funsafe-math-optimizations
                   |multiply instruction would  |generates call to pow where
                   |do                          |multiply instruction would
                   |                            |do
      Known to fail|                            |4.8.3, 4.9.2, 5.0

[Bug middle-end/64225] [4.8/4.9/5 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[wschmidt at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #10 from Bill Schmidt <wschmidt at gcc dot gnu.org> ---
Agreed.  I will test the fix Richard suggested.  Assuming no regressions, does
pre-approval include backports to 4.8 and 4.9?

Thanks,
Bill

[Bug middle-end/64225] [4.8/4.9/5 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[ktkachov at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #11 from ktkachov at gcc dot gnu.org ---
(In reply to Bill Schmidt from comment #10)
> Agreed.  I will test the fix Richard suggested.  Assuming no regressions,
> does pre-approval include backports to 4.8 and 4.9?

Thanks for taking this up. FWIW I've bootstrapped this on x86_64 trunk
succesfully. Will try aarch64 as well.

[Bug middle-end/64225] [4.8/4.9/5 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[wschmidt at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #12 from Bill Schmidt <wschmidt at gcc dot gnu.org> ---
Author: wschmidt
Date: Tue Dec  9 23:02:06 2014
New Revision: 218546

URL: https://gcc.gnu.org/viewcvs?rev=218546&root=gcc&view=rev
Log:
2014-12-09  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>

    PR middle-end/64225
    * tree-ssa-reassoc.c (acceptable_pow_call): Disable transformation
    for BUILT_IN_POW when flag_errno_math is present.


Modified:
    trunk/gcc/ChangeLog
    trunk/gcc/tree-ssa-reassoc.c

[Bug middle-end/64225] [4.8/4.9/5 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[wschmidt at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

Bill Schmidt <wschmidt at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|NEW                         |ASSIGNED

--- Comment #13 from Bill Schmidt <wschmidt at gcc dot gnu.org> ---
Based on comment 11 and my own regression testing, I've committed the fix to
mainline.  I will wait a day or two before backporting to 4.8 and 4.9.

[Bug middle-end/64225] [4.8/4.9 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[rguenth at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |missed-optimization
           Priority|P3                          |P2
      Known to work|                            |5.0
            Summary|[4.8/4.9/5 Regression]      |[4.8/4.9 Regression]
                   |-funsafe-math-optimizations |-funsafe-math-optimizations
                   |generates call to pow where |generates call to pow where
                   |multiply instruction would  |multiply instruction would
                   |do                          |do
      Known to fail|5.0                         |

--- Comment #14 from Richard Biener <rguenth at gcc dot gnu.org> ---
Fixed on trunk sofar.

[Bug middle-end/64225] [4.8/4.9 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[wschmidt at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

--- Comment #16 from Bill Schmidt <wschmidt at gcc dot gnu.org> ---
Author: wschmidt
Date: Wed Dec 10 17:46:33 2014
New Revision: 218587

URL: https://gcc.gnu.org/viewcvs?rev=218587&root=gcc&view=rev
Log:
2014-12-10  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>

    Backport from mainline:
    2014-12-09  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>

    PR middle-end/64225
    * tree-ssa-reassoc.c (acceptable_pow_call): Disable transformation
    for BUILT_IN_POW when flag_errno_math is present.


Modified:
    branches/gcc-4_8-branch/gcc/ChangeLog
    branches/gcc-4_8-branch/gcc/tree-ssa-reassoc.c

[Bug middle-end/64225] [4.8/4.9 Regression] -funsafe-math-optimizations generates call to pow where multiply instruction would do

[wschmidt at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=64225

Bill Schmidt <wschmidt at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|---                         |FIXED

--- Comment #17 from Bill Schmidt <wschmidt at gcc dot gnu.org> ---
Work is complete.