[Bug target/103605] New: [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[Bug target/103605] New: [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[pc at gcc dot gnu.org]

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

            Bug ID: 103605
           Summary: [PowerPC] fmin/fmax should be inlined always with
                    xsmindp/xsmaxdp
           Product: gcc
           Version: 11.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: target
          Assignee: unassigned at gcc dot gnu.org
          Reporter: pc at gcc dot gnu.org
  Target Milestone: ---

--
$ gcc --version
gcc (GCC) 11.2.1 20210728 (Red Hat 11.2.1-2)
[...]
$ gcc -c -O2 fmin.c && objdump -dr fmin.o
   0:   00 00 4c 3c     addis   r2,r12,0
                        0: R_PPC64_REL16_HA     .TOC.
   4:   00 00 42 38     addi    r2,r2,0
                        4: R_PPC64_REL16_LO     .TOC.+0x4
   8:   a6 02 08 7c     mflr    r0
   c:   10 00 01 f8     std     r0,16(r1)
  10:   e1 ff 21 f8     stdu    r1,-32(r1)
  14:   01 00 00 48     bl      14 <fm+0x14>
                        14: R_PPC64_REL24       fmin
  18:   00 00 00 60     nop
  1c:   20 00 21 38     addi    r1,r1,32
  20:   10 00 01 e8     ld      r0,16(r1)
  24:   a6 03 08 7c     mtlr    r0
  28:   20 00 80 4e     blr
$ gcc -c -O2 fmin.c -ffast-math && objdump -dr fmin.o
   0:   40 14 21 f0     xsmincdp vs1,vs1,vs2
   4:   20 00 80 4e     blr
--

And it appears that a better instruction choice in the above case is xsmindp,
and it can be used with and without "-ffast-math", as it matches the semantics
required of fmin.  Similarly, xsmaxdp with fmax.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[pc at gcc dot gnu.org]

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

--- Comment #1 from pc at gcc dot gnu.org ---
$ cat fmin.c
#include <math.h>
double fm (double d0, double d1) {
  return fmin (d0, d1);
}

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[guihaoc at gcc dot gnu.org]

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

HaoChen Gui <guihaoc at gcc dot gnu.org> changed:

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

--- Comment #2 from HaoChen Gui <guihaoc at gcc dot gnu.org> ---
I think both xsmindp and xsmincdp is not consistent with C99/11 standard. So
without fast-math, it can't be implemented by xsmindp/xsmincdp.

C99/11 standard
If just one argument is a NaN, the fmin functions return the other argument (if
both arguments are NaNs, the functions return a NaN).
fmin(NaN, 3.0) = fmin(3.0, NaN) = 3.0

xsmindp
The minimum of a QNaN and any value is that value. The minimum of any value and
an SNaN is that SNaN converted to a QNaN.
xsmindp(NaN, 3.0) = 3.0 xsmindp(3.0, NaN) = NaN

xsmincdp
If either src1 or src2 is a NaN, result is src2.
Otherwise, if src1 is less than src2, result is src1.
Otherwise, result is src2.
xsmincdp(NaN, 3.0) = 3.0 xsmincdp(3.0, NaN) = NaN

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[pc at gcc dot gnu.org]

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

--- Comment #3 from pc at gcc dot gnu.org ---
Here's a test which exercises all three options:
- fmin () (glibc 2.28)
- xsmincdp (ironically, via __builtin_vsx_xsmindp)
- xsmindp (via asm)
--
$ cat xsmindp.c
#include <stdio.h>
#include <math.h>
int main (int argc) {
  double d0 = argc, d1 = argc+1;
  double rf, rb, rx;

  printf ("(src1, src2): fmin b-in asm\n");

  rf = fmin (d0, d1);
  rb = __builtin_vsx_xsmindp (d0, d1);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d0), "wa" (d1));
  printf ("(+3.0, +3.0): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  d1 = NAN;
  rf = fmin (d0, d1);
  rb = __builtin_vsx_xsmindp (d0, d1);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d0), "wa" (d1));
  printf ("(+3.0,  NAN): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  rf = fmin (d1, d0);
  rb = __builtin_vsx_xsmindp (d1, d0);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d1), "wa" (d0));
  printf ("( NAN, +3.0): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  d0 = NAN;
  rf = fmin (d0, d1);
  rb = __builtin_vsx_xsmindp (d0, d1);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d0), "wa" (d1));
  printf ("( NAN,  NAN): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  d0 = argc, d1 = argc+1;

  d1 = __builtin_nans ("0");
  rf = fmin (d0, d1);
  rb = __builtin_vsx_xsmindp (d0, d1);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d0), "wa" (d1));
  printf ("(+3.0, SNAN): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  rf = fmin (d1, d0);
  rb = __builtin_vsx_xsmindp (d1, d0);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d1), "wa" (d0));
  printf ("(SNAN, +3.0): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  d0 = __builtin_nans ("0");
  rf = fmin (d0, d1);
  rb = __builtin_vsx_xsmindp (d0, d1);
  asm ("xsmindp %0,%1,%2" : "=wa" (rx) : "wa" (d0), "wa" (d1));
  printf ("(SNAN, SNAN): %+3.1f %+3.1f %+3.1f\n", rf, rb, rx);

  return 0;
}
$ /opt/gcc-nightly/trunk/bin/gcc --version
gcc (GCC) 12.0.1 20220426 (experimental) [remotes/origin/HEAD
r12-8269-gcd4acb8cd9]
Copyright (C) 2022 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

$ /opt/gcc-nightly/trunk/bin/gcc -fsignaling-nans -D_WANT_SNAN -o xsmindp
xsmindp.c -O0 -lm && ./xsmindp
(src1, src2): fmin b-in asm
(+3.0, +3.0): +1.0 +1.0 +1.0
(+3.0,  NAN): +1.0 +nan +1.0
( NAN, +3.0): +1.0 +1.0 +1.0
( NAN,  NAN): +nan +nan +nan
(+3.0, SNAN): +nan +nan +nan
(SNAN, +3.0): +nan +1.0 +nan
(SNAN, SNAN): +nan +nan +nan
$ /opt/gcc-nightly/trunk/bin/gcc -fsignaling-nans -D_WANT_SNAN -o xsmindp
xsmindp.c -O3 -mcpu=power10 -lm && ./xsmindp
(src1, src2): fmin b-in asm
(+3.0, +3.0): +1.0 +1.0 +1.0
(+3.0,  NAN): +1.0 +nan +1.0
( NAN, +3.0): +1.0 +nan +1.0
( NAN,  NAN): +nan +nan +nan
(+3.0, SNAN): +nan +nan +nan
(SNAN, +3.0): +nan +1.0 +nan
(SNAN, SNAN): +nan +nan +nan
$ /opt/gcc-nightly/trunk/bin/gcc -fsignaling-nans -D_WANT_SNAN -o xsmindp
xsmindp.c -O3 -mcpu=power10 -lm -ffast-math && ./xsmindp
(src1, src2): fmin b-in asm
(+3.0, +3.0): +1.0 +1.0 +1.0
(+3.0,  NAN): +nan +nan +1.0
( NAN, +3.0): +nan +nan +1.0
( NAN,  NAN): +nan +nan +nan
(+3.0, SNAN): +nan +nan +nan
(SNAN, +3.0): +nan +nan +nan
(SNAN, SNAN): +nan +nan +nan
--
Without -ffast-math, the current semantics of fmin() match those of xsmindp.
With -ffast-math, the current semantics of fmin() match those of xsmincdp.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[joseph at codesourcery dot com]

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

--- Comment #4 from joseph at codesourcery dot com <joseph at codesourcery dot com> ---
On Tue, 26 Apr 2022, guihaoc at gcc dot gnu.org via Gcc-bugs wrote:

> C99/11 standard
> If just one argument is a NaN, the fmin functions return the other argument (if
> both arguments are NaNs, the functions return a NaN).
> fmin(NaN, 3.0) = fmin(3.0, NaN) = 3.0

"NaN" here means quiet NaN.

> xsmindp
> The minimum of a QNaN and any value is that value. The minimum of any value and
> an SNaN is that SNaN converted to a QNaN.
> xsmindp(NaN, 3.0) = 3.0 xsmindp(3.0, NaN) = NaN

That seems right for fmin, provided that (QNaN, SNaN) arguments in either 
order produce a QNaN result (with "invalid" raised).  Note that fmin and 
fmax follow the old operations from IEEE 754-2008 (that aren't associative 
in the presence of SNaN), not any of the new operations from IEEE 
754-2019.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[pc at gcc dot gnu.org]

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

--- Comment #5 from pc at gcc dot gnu.org ---
I modified the testcase from comment #3 to clear-before and check-after
FE_INVALID exception bit for each operation:
--
$ /opt/gcc-nightly/trunk/bin/gcc -O2 -o xsmindp-test xsmindp-test.c xsmindp.c
-lm && ./xsmindp-test a b
(src1, src2): fmin:I b-in:I asm:I
(+3.0, +3.0): +3.0;0 +3.0;0 +3.0;0
(+3.0,  NAN): +3.0;0 +nan;0 +3.0;0
( NAN, +3.0): +3.0;0 +3.0;0 +3.0;0
( NAN,  NAN): +nan;0 +nan;0 +nan;0
(+3.0, SNAN): +nan;1 +nan;1 +nan;1
(SNAN, +3.0): +nan;1 +3.0;1 +nan;1
(SNAN, SNAN): +nan;1 +nan;1 +nan;1
$ /opt/gcc-nightly/trunk/bin/gcc -O2 -ffast-math -o xsmindp-test xsmindp-test.c
xsmindp.c -lm && ./xsmindp-test a b
(src1, src2): fmin:I b-in:I asm:I
(+3.0, +3.0): +3.0;0 +3.0;0 +3.0;0
(+3.0,  NAN): +nan;0 +nan;0 +3.0;0
( NAN, +3.0): +3.0;0 +3.0;0 +3.0;0
( NAN,  NAN): +nan;0 +nan;0 +nan;0
(+3.0, SNAN): +nan;1 +nan;1 +nan;1
(SNAN, +3.0): +3.0;1 +3.0;1 +nan;1
(SNAN, SNAN): +nan;1 +nan;1 +nan;1
--
Without -ffast-math, fmin() matches xsmindp.
With -ffast-math, fmin() matches xsmincdp.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[guihaoc at gcc dot gnu.org]

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

--- Comment #6 from HaoChen Gui <guihaoc at gcc dot gnu.org> ---
gcc -O0 -fsignaling-nans -D_WANT_SNAN -lm   -o main main.c && ./main
(nan, 3.0), fmin: 3.0, builtin: 3.0, xsmincdp: 3.0, xsmindp: 3.0
(3.0, nan), fmin: 3.0, builtin: nan, xsmincdp: nan, xsmindp: 3.0
(snan, 3.0), fmin: nan, builtin: 3.0, xsmincdp: 3.0, xsmindp: nan
(3.0, snan), fmin: nan, builtin: snan, xsmincdp: snan, xsmindp: nan
(snan, snan), fmin: nan, builtin: snan, xsmincdp: snan, xsmindp: nan

For 'fmin', the result is qnan if either argument is snan. The result of
'xsmindp' matches 'fmin'. 
I will make patch to implement fmin_optab by xsmindp and fmax_optab by xsmaxdp.
Thanks.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[linkw at gcc dot gnu.org]

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

--- Comment #7 from Kewen Lin <linkw at gcc dot gnu.org> ---
(In reply to pc from comment #5)
> I modified the testcase from comment #3 to clear-before and check-after
> FE_INVALID exception bit for each operation:
> --
> $ /opt/gcc-nightly/trunk/bin/gcc -O2 -o xsmindp-test xsmindp-test.c
> xsmindp.c -lm && ./xsmindp-test a b
> (src1, src2): fmin:I b-in:I asm:I
> (+3.0, +3.0): +3.0;0 +3.0;0 +3.0;0
> (+3.0,  NAN): +3.0;0 +nan;0 +3.0;0
> ( NAN, +3.0): +3.0;0 +3.0;0 +3.0;0
> ( NAN,  NAN): +nan;0 +nan;0 +nan;0
> (+3.0, SNAN): +nan;1 +nan;1 +nan;1
> (SNAN, +3.0): +nan;1 +3.0;1 +nan;1
> (SNAN, SNAN): +nan;1 +nan;1 +nan;1
> $ /opt/gcc-nightly/trunk/bin/gcc -O2 -ffast-math -o xsmindp-test
> xsmindp-test.c xsmindp.c -lm && ./xsmindp-test a b
> (src1, src2): fmin:I b-in:I asm:I
> (+3.0, +3.0): +3.0;0 +3.0;0 +3.0;0
> (+3.0,  NAN): +nan;0 +nan;0 +3.0;0
> ( NAN, +3.0): +3.0;0 +3.0;0 +3.0;0
> ( NAN,  NAN): +nan;0 +nan;0 +nan;0
> (+3.0, SNAN): +nan;1 +nan;1 +nan;1
> (SNAN, +3.0): +3.0;1 +3.0;1 +nan;1
> (SNAN, SNAN): +nan;1 +nan;1 +nan;1
> --
> Without -ffast-math, fmin() matches xsmindp.
> With -ffast-math, fmin() matches xsmincdp.

Nice test case! We probably can note this matching to xs{min,max}dp as one
small "Programming Note" in ISA document.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[segher at gcc dot gnu.org]

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

--- Comment #8 from Segher Boessenkool <segher at gcc dot gnu.org> ---
(In reply to joseph@codesourcery.com from comment #4)
> > xsmindp
> > The minimum of a QNaN and any value is that value. The minimum of any value and
> > an SNaN is that SNaN converted to a QNaN.
> > xsmindp(NaN, 3.0) = 3.0 xsmindp(3.0, NaN) = NaN
> 
> That seems right for fmin, provided that (QNaN, SNaN) arguments in either 
> order produce a QNaN result (with "invalid" raised).

They do, and they return a QNaN with the payload of the first operand, in both
cases.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[cvs-commit at gcc dot gnu.org]

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

--- Comment #9 from CVS Commits <cvs-commit at gcc dot gnu.org> ---
The master branch has been updated by HaoChen Gui <guihaoc@gcc.gnu.org>:

https://gcc.gnu.org/g:54ce3cbd285d453b954c281bb3ad38bee2f65330

commit r14-2758-g54ce3cbd285d453b954c281bb3ad38bee2f65330
Author: Haochen Gui <guihaoc@gcc.gnu.org>
Date:   Tue Jul 25 10:40:37 2023 +0800

    rs6000: Implemented f[min/max]_optab by xs[min/max]dp

    gcc/
            PR target/103605
            * config/rs6000/rs6000-builtin.cc (rs6000_gimple_fold_builtin):
Gimple
            fold RS6000_BIF_XSMINDP and RS6000_BIF_XSMAXDP when fast-math is
set.
            * config/rs6000/rs6000.md (FMINMAX): New int iterator.
            (minmax_op): New int attribute.
            (UNSPEC_FMAX, UNSPEC_FMIN): New unspecs.
            (f<minmax_op><mode>3): New pattern by UNSPEC_FMAX and UNSPEC_FMIN.
            * config/rs6000/rs6000-builtins.def (__builtin_vsx_xsmaxdp): Set
            pattern to fmaxdf3.
            (__builtin_vsx_xsmindp): Set pattern to fmindf3.

    gcc/testsuite/
            PR target/103605
            * gcc.target/powerpc/pr103605.h: New.
            * gcc.target/powerpc/pr103605-1.c: New.
            * gcc.target/powerpc/pr103605-2.c: New.

[Bug target/103605] [PowerPC] fmin/fmax should be inlined always with xsmindp/xsmaxdp

[guihaoc at gcc dot gnu.org]

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

HaoChen Gui <guihaoc at gcc dot gnu.org> changed:

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

--- Comment #10 from HaoChen Gui <guihaoc at gcc dot gnu.org> ---
Fixed.