changeset 9721:9e1dc7ba8db3

8015396: double a%b returns NaN for some (a,b) (|a| < inf, |b|>0) Reviewed-by: coleenp, gtriantafill
author ctornqvi
date Thu, 10 Dec 2015 09:42:22 -0800
parents f52a36722338
children b373da0bc248
files src/os/windows/vm/sharedRuntimeRem.cpp src/share/vm/runtime/sharedRuntime.cpp src/share/vm/runtime/sharedRuntime.hpp test/compiler/floatingpoint/ModNaN.java
diffstat 4 files changed, 174 insertions(+), 3 deletions(-) [+]
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/os/windows/vm/sharedRuntimeRem.cpp	Thu Dec 10 09:42:22 2015 -0800
@@ -0,0 +1,162 @@
+/*
+* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*
+*/
+
+#include "precompiled.hpp"
+
+#ifdef _WIN64
+// These are copied defines from fdlibm.h, this allows us to keep the code
+// the same as in the JDK, for easier maintenance.
+
+#define __HI(x) *(1+(int*)&x)
+#define __LO(x) *(int*)&x
+
+// This code is a copy of __ieee754_fmod() from the JDK's libfdlibm and is
+// used as a workaround for issues with the Windows x64 CRT implementation
+// of fmod. Microsoft has acknowledged that this is an issue in Visual Studio
+// 2012 and forward, but has not provided a time frame for a fix other than that
+// it'll not be fixed in Visual Studio 2013 or 2015.
+
+static const double one = 1.0, Zero[] = { 0.0, -0.0, };
+
+double SharedRuntime::fmod_winx64(double x, double y)
+{
+  int n, hx, hy, hz, ix, iy, sx, i;
+  unsigned lx, ly, lz;
+
+  hx = __HI(x);           /* high word of x */
+  lx = __LO(x);           /* low  word of x */
+  hy = __HI(y);           /* high word of y */
+  ly = __LO(y);           /* low  word of y */
+  sx = hx & 0x80000000;             /* sign of x */
+  hx ^= sx;                /* |x| */
+  hy &= 0x7fffffff;       /* |y| */
+
+#pragma warning( disable : 4146 )
+  /* purge off exception values */
+  if ((hy | ly) == 0 || (hx >= 0x7ff00000) ||       /* y=0,or x not finite */
+    ((hy | ((ly | -ly) >> 31))>0x7ff00000))     /* or y is NaN */
+#pragma warning( default : 4146 )
+    return (x*y) / (x*y);
+  if (hx <= hy) {
+    if ((hx<hy) || (lx<ly)) return x;      /* |x|<|y| return x */
+    if (lx == ly)
+      return Zero[(unsigned)sx >> 31];  /* |x|=|y| return x*0*/
+  }
+
+  /* determine ix = ilogb(x) */
+  if (hx<0x00100000) {     /* subnormal x */
+    if (hx == 0) {
+      for (ix = -1043, i = lx; i>0; i <<= 1) ix -= 1;
+    }
+    else {
+      for (ix = -1022, i = (hx << 11); i>0; i <<= 1) ix -= 1;
+    }
+  }
+  else ix = (hx >> 20) - 1023;
+
+  /* determine iy = ilogb(y) */
+  if (hy<0x00100000) {     /* subnormal y */
+    if (hy == 0) {
+      for (iy = -1043, i = ly; i>0; i <<= 1) iy -= 1;
+    }
+    else {
+      for (iy = -1022, i = (hy << 11); i>0; i <<= 1) iy -= 1;
+    }
+  }
+  else iy = (hy >> 20) - 1023;
+
+  /* set up {hx,lx}, {hy,ly} and align y to x */
+  if (ix >= -1022)
+    hx = 0x00100000 | (0x000fffff & hx);
+  else {          /* subnormal x, shift x to normal */
+    n = -1022 - ix;
+    if (n <= 31) {
+      hx = (hx << n) | (lx >> (32 - n));
+      lx <<= n;
+    }
+    else {
+      hx = lx << (n - 32);
+      lx = 0;
+    }
+  }
+  if (iy >= -1022)
+    hy = 0x00100000 | (0x000fffff & hy);
+  else {          /* subnormal y, shift y to normal */
+    n = -1022 - iy;
+    if (n <= 31) {
+      hy = (hy << n) | (ly >> (32 - n));
+      ly <<= n;
+    }
+    else {
+      hy = ly << (n - 32);
+      ly = 0;
+    }
+  }
+
+  /* fix point fmod */
+  n = ix - iy;
+  while (n--) {
+    hz = hx - hy; lz = lx - ly; if (lx<ly) hz -= 1;
+    if (hz<0){ hx = hx + hx + (lx >> 31); lx = lx + lx; }
+    else {
+      if ((hz | lz) == 0)          /* return sign(x)*0 */
+        return Zero[(unsigned)sx >> 31];
+      hx = hz + hz + (lz >> 31); lx = lz + lz;
+    }
+  }
+  hz = hx - hy; lz = lx - ly; if (lx<ly) hz -= 1;
+  if (hz >= 0) { hx = hz; lx = lz; }
+
+  /* convert back to floating value and restore the sign */
+  if ((hx | lx) == 0)                  /* return sign(x)*0 */
+    return Zero[(unsigned)sx >> 31];
+  while (hx<0x00100000) {          /* normalize x */
+    hx = hx + hx + (lx >> 31); lx = lx + lx;
+    iy -= 1;
+  }
+  if (iy >= -1022) {        /* normalize output */
+    hx = ((hx - 0x00100000) | ((iy + 1023) << 20));
+    __HI(x) = hx | sx;
+    __LO(x) = lx;
+  }
+  else {                /* subnormal output */
+    n = -1022 - iy;
+    if (n <= 20) {
+      lx = (lx >> n) | ((unsigned)hx << (32 - n));
+      hx >>= n;
+    }
+    else if (n <= 31) {
+      lx = (hx << (32 - n)) | (lx >> n); hx = sx;
+    }
+    else {
+      lx = hx >> (n - 32); hx = sx;
+    }
+    __HI(x) = hx | sx;
+    __LO(x) = lx;
+    x *= one;           /* create necessary signal */
+  }
+  return x;               /* exact output */
+}
+
+#endif
--- a/src/share/vm/runtime/sharedRuntime.cpp	Thu Dec 10 17:03:48 2015 +0100
+++ b/src/share/vm/runtime/sharedRuntime.cpp	Thu Dec 10 09:42:22 2015 -0800
@@ -254,8 +254,10 @@
        ((ybits.i & float_sign_mask) == float_infinity) ) {
     return x;
   }
+  return ((jfloat)fmod_winx64((double)x, (double)y));
+#else
+  return ((jfloat)fmod((double)x,(double)y));
 #endif
-  return ((jfloat)fmod((double)x,(double)y));
 JRT_END
 
 
@@ -269,8 +271,10 @@
        ((ybits.l & double_sign_mask) == double_infinity) ) {
     return x;
   }
+  return ((jdouble)fmod_winx64((double)x, (double)y));
+#else
+  return ((jdouble)fmod((double)x,(double)y));
 #endif
-  return ((jdouble)fmod((double)x,(double)y));
 JRT_END
 
 #ifdef __SOFTFP__
--- a/src/share/vm/runtime/sharedRuntime.hpp	Thu Dec 10 17:03:48 2015 +0100
+++ b/src/share/vm/runtime/sharedRuntime.hpp	Thu Dec 10 09:42:22 2015 -0800
@@ -100,6 +100,12 @@
   static jfloat  frem(jfloat  x, jfloat  y);
   static jdouble drem(jdouble x, jdouble y);
 
+
+#ifdef _WIN64
+  // Workaround for fmod issue in the Windows x64 CRT
+  static double fmod_winx64(double x, double y);
+#endif
+
 #ifdef __SOFTFP__
   static jfloat  fadd(jfloat x, jfloat y);
   static jfloat  fsub(jfloat x, jfloat y);
--- a/test/compiler/floatingpoint/ModNaN.java	Thu Dec 10 17:03:48 2015 +0100
+++ b/test/compiler/floatingpoint/ModNaN.java	Thu Dec 10 09:42:22 2015 -0800
@@ -25,7 +25,6 @@
  * @test
  * @bug 8015396
  * @summary double a%b returns NaN for some (a,b) (|a| < inf, |b|>0) (on Core i7 980X)
- * @ignore 8015396
  * @run main ModNaN
  */
 public class ModNaN {