[Bug libgcj/26483] New: Wrong parsing of doubles when interpreted

[Bug libgcj/26483] New: Wrong parsing of doubles when interpreted

[konqueror at gmx dot de]

I tried to run the attached test case on IA64 native and interpreted. The bad
news is that both give totally different results:

Native:

mkoch@merulo:~$ gcj-4.0 DoubleTest.java -o doubleTest --main=DoubleTest -g
mkoch@merulo:~$ ./doubleTest
5.0E-324

Interpreted:

mkoch@merulo:~$ gij-4.0 DoubleTest
8.881784197001252E-16

The interpreted case is wrong. This seems to be a bug in fdlibm as
jamvm/classpath has the same bug. This bug only happens on IA64 as far as I
know. E.g. it makes building GNU classpath fail with ecj. I wonder what GCJ
does that makes this work in the native case ...


-- 
           Summary: Wrong parsing of doubles when interpreted
           Product: gcc
           Version: 4.0.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: libgcj
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: konqueror at gmx dot de
 GCC build triplet: ia64-linux-gnu
  GCC host triplet: ia64-linux-gnu
GCC target triplet: ia64-linux-gnu


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[konqueror at gmx dot de]

------- Comment #1 from konqueror at gmx dot de  2006-02-27 16:20 -------
Created an attachment (id=10921)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=10921&action=view)
Testcase


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[pinskia at gcc dot gnu dot org]

------- Comment #2 from pinskia at gcc dot gnu dot org  2006-02-27 17:03 -------
Isn't this the "64bit"  issue with  fdlibm?


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[konqueror at gmx dot de]

------- Comment #3 from konqueror at gmx dot de  2006-02-27 17:26 -------
I dont think so as the testcase works correctly on amd64.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[wilson at gcc dot gnu dot org]

------- Comment #4 from wilson at gcc dot gnu dot org  2006-02-28 03:25 -------
The number 5e-324 exceeds the range of the (C language) double type.  So the
result you get will depend on how overflow is handled.  If I use a number
within the range of double, it works fine.  I don't know what Java is supposed
to do in the presence of overflow here.

Compile this with -E
#include <float.h>
DBL_MIN_10_EXP
and we get a result of -307.  So 5e-324 is an out-of-range number.

The number is within range of an IA-64/x86 80-bit FP long double number. 
LDBL_MIN_10_EXP is -4931.  So if long doubles are being used, intentionally or
accidentally, this could work.

On an x86_64 system, I get an answer of 0.0 for both the compiled and
interpreted tests.  If I use -m32 when compiling, I get the answer "5E-324".  I
don't have a 32-bit compiled interpreter, so I can't check that.

Without access to a copy of the Java standard, it isn't clear to me what the
correct answer is here.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[joseph at codesourcery dot com]

------- Comment #5 from joseph at codesourcery dot com  2006-02-28 21:15 -------
Subject: Re:  Wrong parsing of doubles when interpreted

On Tue, 28 Feb 2006, wilson at gcc dot gnu dot org wrote:

> The number 5e-324 exceeds the range of the (C language) double type.  So the

It's (just) within the range of denormal values for IEEE double precision.

> Without access to a copy of the Java standard, it isn't clear to me what the
> correct answer is here.

The question is how denormal values should be handled by Java here.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[schwab at suse dot de]

------- Comment #6 from schwab at suse dot de  2006-02-28 21:40 -------
(In reply to comment #5)
> > The number 5e-324 exceeds the range of the (C language) double type.  So the
> 
> It's (just) within the range of denormal values for IEEE double precision.

5e-324 is already out of range.  The limit is about 4.941e–324.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[joseph at codesourcery dot com]

------- Comment #7 from joseph at codesourcery dot com  2006-02-28 21:50 -------
Subject: Re:  Wrong parsing of doubles when interpreted

On Tue, 28 Feb 2006, schwab at suse dot de wrote:

> 
> 
> ------- Comment #6 from schwab at suse dot de  2006-02-28 21:40 -------
> (In reply to comment #5)
> > > The number 5e-324 exceeds the range of the (C language) double type.  So the
> > 
> > It's (just) within the range of denormal values for IEEE double precision.
> 
> 5e-324 is already out of range.  The limit is about 4.941e–324.

4.941e-324 < 5e-324.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted

[schwab at suse dot de]

------- Comment #8 from schwab at suse dot de  2006-02-28 22:02 -------
Yes, it's already too late here. :-)


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[tromey at gcc dot gnu dot org]

------- Comment #9 from tromey at gcc dot gnu dot org  2006-03-06 17:08 -------
You can read about the java programming language's requirements
for floating point here:

http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.2.3

Relevant quote:

  In particular, the Java programming language requires support of IEEE 754
  denormalized floating-point numbers and gradual underflow


-- 

tromey at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |tromey at gcc dot gnu dot
                   |                            |org


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #10 from wilson at gcc dot gnu dot org  2006-03-08 00:46 -------
I missed the denorm angle obviously.  And the answer to the question about what
is different between native and interpreted execution would of course be
libffi, which took me far longer to remember than it should have.

Anyways, looking at libffi, the issue appears to be the stf_spill function in
the src/ia64/ffi.c file.  This function spills an FP value to the stack, taking
as argument a _float80 value, which is effectively a long double.  So when we
pass the denorm double to stf_spill, it gets normalized to a long double, and
this normalization appears to be causing all of the trouble.  This long double
value then gets passed to dtoa in fdlibm which expects a double argument.  dtoa
then fails.  I didn't debug dtoa to see why it fails, but it seems clear if we
pass it an argument of the wrong type, we are asking for trouble.

On IA-64, FP values are always stored in FP regs as a long double value rounded
to the appropriate type, so the normalization will have no effect except on
denorm values I think.  This means only single-denorm and double-denorm
arguments values are broken, which is something that would be easy to miss
without a testcase.

Stepping through ffi_call in gdb at the point whjere stf_spill is called, I see
the incoming value is 
f6             4.9406564584124654417656879286822137e-324        (raw
0x000000000000fc010000000000000800)
which has the minimum double exponent (fc01) and a denorm fraction (0...800). 
After the conversion to _float80, we have
f6             4.9406564584124654417656879286822137e-324        (raw
0x000000000000fbcd8000000000000000)
This now has an exponent invalid for double (fbcd) and a normal fraction
(800...0).

If I rewrite stf_spill to be a macro instead of a function, to avoid the
argument type conversion, then the testcase works for both gcj and gij.

ldf_spill appears to have the same problem, and is in need of the same
solution.


-- 

wilson at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |wilson at gcc dot gnu dot
                   |                            |org


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #11 from wilson at gcc dot gnu dot org  2006-03-08 00:51 -------
Created an attachment (id=10989)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=10989&action=view)
unfinished untested patch to fix stf_spill bug in ia64 libffi port

This is unfinished.  It needs to be a bit cleaner, and also ldf_spill appears
to need the same fix.

This is untested, except for the testcase.  It does make the testcase work.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[tromey at gcc dot gnu dot org]

------- Comment #12 from tromey at gcc dot gnu dot org  2006-04-04 19:07 -------
Created an attachment (id=11207)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=11207&action=view)
reduced test case

I tried to reduce this to a C test case suitable for inclusion
in libffi.  I've attached this.  Unfortunately on the ia64 machine
I tried, it does not fail.  I haven't looked to see what I
might have done wrong.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at tuliptree dot org]

------- Comment #13 from wilson at tuliptree dot org  2006-04-04 20:22 -------
Subject: Re:  Wrong parsing of doubles when interpreted
        on ia64

On Tue, 2006-04-04 at 12:07, tromey at gcc dot gnu dot org wrote:
> I tried to reduce this to a C test case suitable for inclusion
> in libffi.  I've attached this.  Unfortunately on the ia64 machine
> I tried, it does not fail.  I haven't looked to see what I
> might have done wrong.

I was able to write a testcase that showed the problem.  I based it on
float1.c, changed to accept and return a double, initialize input arg
with a denorm value, and using an exact check instead of a delta check
after the call.  The delta checks don't work for a denorm.  Since I am
not doing any arithmetic, we should get the same value back.  I see I
forgot to change the comment though, that will have to be fixed.  This
testcase reproduces the bug for me, and is fixed by my unfinished
patch.  I'll attach my testcase to the PR.

I think your testcase doesn't work because you aren't actually calling a
function that takes and return double arguments.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #14 from wilson at gcc dot gnu dot org  2006-04-04 20:24 -------
Created an attachment (id=11208)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=11208&action=view)
proposed testcase, based on float1.c

This reproduces the denorm failure for me with unpatched sources, and worked
with my proposed unfinished patch.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[andreast at gcc dot gnu dot org]

------- Comment #15 from andreast at gcc dot gnu dot org  2006-04-04 20:46 -------
Great, a libffi test case!
Would you mind adding a reference to the PR in the test case header and adjust
the 'int i' in main to 'unsigned int i'? If you feel ok with the test case then
please commit to trunk.

Thanks,
Andreas


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at tuliptree dot org]

------- Comment #16 from wilson at tuliptree dot org  2006-04-07 23:00 -------
Subject: Re:  Wrong parsing of doubles when interpreted
        on ia64

On Tue, 2006-04-04 at 13:46, andreast at gcc dot gnu dot org wrote:
> ------- Comment #15 from andreast at gcc dot gnu dot org  2006-04-04 20:46 -------
> Would you mind adding a reference to the PR in the test case header and adjust
> the 'int i' in main to 'unsigned int i'? If you feel ok with the test case then
> please commit to trunk.

I added the PR number, and fixed the comment about the delta check.

I see that the float1.c file on mainline is different than the gcc-4.0.x
float1.c file that I started with.  I adjusted my testcase to match,
changing the 'int i' to 'unsigned int i', and deleting one spurious
space char.

I retested on mainline with ia64 unpatched, ia64 patched, x86_64, and
x86_64/-m32.  It failed for the first one, and worked for the other 3,
as expected.  I will go ahead and check it in.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #17 from wilson at gcc dot gnu dot org  2006-04-07 23:04 -------
Subject: Bug 26483

Author: wilson
Date: Fri Apr  7 23:04:15 2006
New Revision: 112768

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=112768
Log:
For PR 26483, IA-64 denorm failure due to unwanted rounding.
* testsuite/libffi.call/float4.c: New testcase.

Added:
    trunk/libffi/testsuite/libffi.call/float4.c
Modified:
    trunk/libffi/ChangeLog


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #18 from wilson at gcc dot gnu dot org  2006-04-12 22:10 -------
Subject: Bug 26483

Author: wilson
Date: Wed Apr 12 22:10:49 2006
New Revision: 112900

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=112900
Log:
Fix IA-64 problems with denorms getting clobbered by type conversions.
PR libgcj/26483
* src/ia64/ffi.c (stf_spill, ldf_fill): Rewrite as macros.
(hfa_type_load): Call stf_spill.
(hfa_type_store): Call ldf_fill.
(ffi_call): Adjust calls to above routines.  Add local temps for
macro result.

Modified:
    trunk/libffi/ChangeLog
    trunk/libffi/src/ia64/ffi.c


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #19 from wilson at gcc dot gnu dot org  2006-04-12 22:21 -------
IA-64.  Mine.


-- 

wilson at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         AssignedTo|unassigned at gcc dot gnu   |wilson at gcc dot gnu dot
                   |dot org                     |org
             Status|UNCONFIRMED                 |ASSIGNED
     Ever Confirmed|0                           |1
   Last reconfirmed|0000-00-00 00:00:00         |2006-04-12 22:21:46
               date|                            |


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #20 from wilson at gcc dot gnu dot org  2006-04-12 22:22 -------
Fixed on mainline.  Testcase added to mainline.  The fix should probably be
backported to one or more active release branches.


-- 

wilson at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|wilson at gcc dot gnu dot   |
                   |org                         |


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[konqueror at gmx dot de]

------- Comment #21 from konqueror at gmx dot de  2006-05-26 14:58 -------
Can this please get backportet to the 4.1 branch? This bug is still holding
back some Java stuff on Debian/ia64 from being working.


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[wilson at gcc dot gnu dot org]

------- Comment #22 from wilson at gcc dot gnu dot org  2006-06-01 22:36 -------
Subject: Bug 26483

Author: wilson
Date: Thu Jun  1 22:36:19 2006
New Revision: 114319

URL: http://gcc.gnu.org/viewcvs?root=gcc&view=rev&rev=114319
Log:
Fix broken denorm support.
PR libgcj/26483
* src/ia64/ffi.c (stf_spill, ldf_fill): Rewrite as macros.
(hfa_type_load): Call stf_spill.
(hfa_type_store): Call ldf_fill.
(ffi_call): Adjust calls to above routines.  Add local temps for
macro result.

Modified:
    branches/gcc-4_1-branch/libffi/ChangeLog
    branches/gcc-4_1-branch/libffi/src/ia64/ffi.c


-- 


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

[Bug libgcj/26483] Wrong parsing of doubles when interpreted on ia64

[tromey at gcc dot gnu dot org]

------- Comment #23 from tromey at gcc dot gnu dot org  2006-06-17 01:01 -------
Fixed on the 4.1 branch and trunk.
AFAIK nobody is planning to backport to the 4.0 branch, so I'm closing.


-- 

tromey at gcc dot gnu dot org changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|ASSIGNED                    |RESOLVED
         Resolution|                            |FIXED
   Target Milestone|---                         |4.1.2


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