--- a/jdk/test/java/lang/Double/BitwiseConversion.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Double/BitwiseConversion.java	Fri Aug 22 14:56:09 2014 -0700
@@ -25,21 +25,23 @@
  * @test
  * @bug 5037596
  * @summary Verify bitwise conversion works for non-canonical NaN values
+ * @library ../Math
+ * @build DoubleConsts
+ * @run main BitwiseConversion
  * @author Joseph D. Darcy
  */
 
 import static java.lang.Double.*;
-import static sun.misc.DoubleConsts.*;
 
 public class BitwiseConversion {
     static int testNanCase(long x) {
         int errors  = 0;
         // Strip out sign and exponent bits
-        long y = x & SIGNIF_BIT_MASK;
+        long y = x & DoubleConsts.SIGNIF_BIT_MASK;
 
         double values[] = {
-            longBitsToDouble(EXP_BIT_MASK | y),
-            longBitsToDouble(SIGN_BIT_MASK | EXP_BIT_MASK | y)
+            longBitsToDouble(DoubleConsts.EXP_BIT_MASK | y),
+            longBitsToDouble(DoubleConsts.SIGN_BIT_MASK | DoubleConsts.EXP_BIT_MASK | y)
         };
 
         for(double value: values) {
@@ -60,7 +62,7 @@
     public static void main(String... argv) {
         int errors = 0;
 
-        for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) {
+        for (int i = 0; i < DoubleConsts.SIGNIFICAND_WIDTH-1; i++) {
             errors += testNanCase(1L<<i);
         }
 

--- a/jdk/test/java/lang/Double/ParseHexFloatingPoint.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Double/ParseHexFloatingPoint.java	Fri Aug 22 14:56:09 2014 -0700
@@ -30,7 +30,6 @@
 
 
 import java.util.regex.*;
-import sun.misc.DoubleConsts;
 
 public class ParseHexFloatingPoint {
     private ParseHexFloatingPoint(){}
@@ -158,8 +157,8 @@
         }
 
         long bigExponents [] = {
-            2*DoubleConsts.MAX_EXPONENT,
-            2*DoubleConsts.MIN_EXPONENT,
+            2*Double.MAX_EXPONENT,
+            2*Double.MIN_EXPONENT,
 
             (long)Integer.MAX_VALUE-1,
             (long)Integer.MAX_VALUE,
@@ -226,11 +225,11 @@
             new PairSD("0x1.000000000000001p-1075",     Double.MIN_VALUE),
 
             // More subnormal rounding tests
-            new PairSD("0x0.fffffffffffff7fffffp-1022", Math.nextDown(DoubleConsts.MIN_NORMAL)),
-            new PairSD("0x0.fffffffffffff8p-1022",      DoubleConsts.MIN_NORMAL),
-            new PairSD("0x0.fffffffffffff800000001p-1022",DoubleConsts.MIN_NORMAL),
-            new PairSD("0x0.fffffffffffff80000000000000001p-1022",DoubleConsts.MIN_NORMAL),
-            new PairSD("0x1.0p-1022",                   DoubleConsts.MIN_NORMAL),
+            new PairSD("0x0.fffffffffffff7fffffp-1022", Math.nextDown(Double.MIN_NORMAL)),
+            new PairSD("0x0.fffffffffffff8p-1022",      Double.MIN_NORMAL),
+            new PairSD("0x0.fffffffffffff800000001p-1022",Double.MIN_NORMAL),
+            new PairSD("0x0.fffffffffffff80000000000000001p-1022",Double.MIN_NORMAL),
+            new PairSD("0x1.0p-1022",                   Double.MIN_NORMAL),
 
 
             // Large value and overflow rounding tests

--- a/jdk/test/java/lang/Double/ToHexString.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Double/ToHexString.java	Fri Aug 22 14:56:09 2014 -0700
@@ -25,11 +25,13 @@
  * @test
  * @bug 4826774 4926547
  * @summary Tests for {Float, Double}.toHexString methods
+ * @library ../Math
+ * @build DoubleConsts
+ * @run main ToHexString
  * @author Joseph D. Darcy
  */
 
 import java.util.regex.*;
-import sun.misc.DoubleConsts;
 
 public class ToHexString {
     private ToHexString() {}
@@ -83,7 +85,7 @@
                     DoubleConsts.EXP_BIAS;
                 result.append("0x");
 
-                if (exponent == DoubleConsts.MIN_EXPONENT - 1) { // zero or subnormal
+                if (exponent == Double.MIN_EXPONENT - 1) { // zero or subnormal
                     if(signifString.equals("0000000000000")) {
                         result.append("0.0p0");
                     }

--- a/jdk/test/java/lang/Float/BitwiseConversion.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Float/BitwiseConversion.java	Fri Aug 22 14:56:09 2014 -0700
@@ -25,21 +25,23 @@
  * @test
  * @bug 5037596
  * @summary Verify bitwise conversion works for non-canonical NaN values
+ * @library ../Math
+ * @build FloatConsts
+ * @run main BitwiseConversion
  * @author Joseph D. Darcy
  */
 
 import static java.lang.Float.*;
-import static sun.misc.FloatConsts.*;
 
 public class BitwiseConversion {
     static int testNanCase(int x) {
         int errors  = 0;
         // Strip out sign and exponent bits
-        int y = x & SIGNIF_BIT_MASK;
+        int y = x & FloatConsts.SIGNIF_BIT_MASK;
 
         float values[] = {
-            intBitsToFloat(EXP_BIT_MASK | y),
-            intBitsToFloat(SIGN_BIT_MASK | EXP_BIT_MASK | y)
+            intBitsToFloat(FloatConsts.EXP_BIT_MASK | y),
+            intBitsToFloat(FloatConsts.SIGN_BIT_MASK | FloatConsts.EXP_BIT_MASK | y)
         };
 
         for(float value: values) {
@@ -60,7 +62,7 @@
     public static void main(String... argv) {
         int errors = 0;
 
-        for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) {
+        for (int i = 0; i < FloatConsts.SIGNIFICAND_WIDTH-1; i++) {
             errors += testNanCase(1<<i);
         }
 

--- a/jdk/test/java/lang/Math/CeilAndFloorTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/CeilAndFloorTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -27,8 +27,6 @@
  * @summary Check for correct implementation of Math.ceil and Math.floor
  */
 
-import sun.misc.DoubleConsts;
-
 public class CeilAndFloorTests {
     private static int testCeilCase(double input, double expected) {
         int failures = 0;
@@ -139,10 +137,10 @@
         double [][] testCases = {
             { Double.MIN_VALUE,                           1.0},
             {-Double.MIN_VALUE,                          -0.0},
-            { Math.nextDown(DoubleConsts.MIN_NORMAL),     1.0},
-            {-Math.nextDown(DoubleConsts.MIN_NORMAL),    -0.0},
-            { DoubleConsts.MIN_NORMAL,                    1.0},
-            {-DoubleConsts.MIN_NORMAL,                   -0.0},
+            { Math.nextDown(Double.MIN_NORMAL),           1.0},
+            {-Math.nextDown(Double.MIN_NORMAL),          -0.0},
+            { Double.MIN_NORMAL,                          1.0},
+            {-Double.MIN_NORMAL,                         -0.0},
 
             { 0.1,                                        1.0},
             {-0.1,                                       -0.0},

--- a/jdk/test/java/lang/Math/CubeRootTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/CubeRootTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 public class CubeRootTests {
     private CubeRootTests(){}
 
@@ -93,7 +91,7 @@
         }
 
         // Test cbrt(2^(3n)) = 2^n.
-        for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) {
+        for(int i = 18; i <= Double.MAX_EXPONENT/3; i++) {
             failures += testCubeRootCase(Math.scalb(1.0, 3*i),
                                          Math.scalb(1.0, i) );
         }
@@ -240,7 +238,7 @@
             double pcNeighborsStrictCbrt[] = new double[5];
 
             // Test near cbrt(2^(3n)) = 2^n.
-            for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) {
+            for(int i = 18; i <= Double.MAX_EXPONENT/3; i++) {
                 double pc = Math.scalb(1.0, 3*i);
 
                 pcNeighbors[2] = pc;

--- a/jdk/test/java/lang/Math/Expm1Tests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/Expm1Tests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 /*
  * The Taylor expansion of expxm1(x) = exp(x) -1 is
  *
@@ -99,7 +97,7 @@
         }
 
         // For x > 710, expm1(x) should be infinity
-        for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
             double d = Math.scalb(2, i);
             failures += testExpm1Case(d, infinityD);
         }
@@ -116,7 +114,7 @@
                                                  reachedLimit);
         }
 
-        for(int i = 7; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 7; i <= Double.MAX_EXPONENT; i++) {
             double d = -Math.scalb(2, i);
             failures += testExpm1CaseWithUlpDiff(d, -1.0, 1, reachedLimit);
         }

--- a/jdk/test/java/lang/Math/HyperbolicTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/HyperbolicTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 public class HyperbolicTests {
     private HyperbolicTests(){}
 
@@ -342,7 +340,7 @@
 
         // sinh(x) overflows for values greater than 710; in
         // particular, it overflows for all 2^i, i > 10.
-        for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
             double d = Math.scalb(2.0, i);
 
             // Result and expected are the same.
@@ -701,7 +699,7 @@
 
         // cosh(x) overflows for values greater than 710; in
         // particular, it overflows for all 2^i, i > 10.
-        for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
             double d = Math.scalb(2.0, i);
 
             // Result and expected are the same.
@@ -996,7 +994,7 @@
             failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5);
         }
 
-        for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 5; i <= Double.MAX_EXPONENT; i++) {
             double d = Math.scalb(2.0, i);
 
             failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5);

--- a/jdk/test/java/lang/Math/HypotTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/HypotTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 public class HypotTests {
     private HypotTests(){}
 
@@ -87,7 +85,7 @@
         // Verify hypot(x, 0.0) is close to x over the entire exponent
         // range.
         for(int i = DoubleConsts.MIN_SUB_EXPONENT;
-            i <= DoubleConsts.MAX_EXPONENT;
+            i <= Double.MAX_EXPONENT;
             i++) {
             double input = Math.scalb(2, i);
             failures += testHypotCase(input, 0.0, input);
@@ -125,7 +123,7 @@
         for(int i = 0; i < 1000; i++) {
             double d = rand.nextDouble();
             // Scale d to have an exponent equal to MAX_EXPONENT -15
-            d = Math.scalb(d, DoubleConsts.MAX_EXPONENT
+            d = Math.scalb(d, Double.MAX_EXPONENT
                                  -15 - Tests.ilogb(d));
             for(int j = 0; j <= 13; j += 1) {
                 failures += testHypotCase(3*d, 4*d, 5*d, 2.5);

--- a/jdk/test/java/lang/Math/IeeeRecommendedTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/IeeeRecommendedTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,9 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-import sun.misc.FloatConsts;
-
 public class IeeeRecommendedTests {
     private IeeeRecommendedTests(){}
 
@@ -54,7 +51,7 @@
      * Returns a floating-point power of two in the normal range.
      */
     static double powerOfTwoD(int n) {
-        return Double.longBitsToDouble((((long)n + (long)DoubleConsts.MAX_EXPONENT) <<
+        return Double.longBitsToDouble((((long)n + (long)Double.MAX_EXPONENT) <<
                                         (DoubleConsts.SIGNIFICAND_WIDTH-1))
                                        & DoubleConsts.EXP_BIT_MASK);
     }
@@ -63,7 +60,7 @@
      * Returns a floating-point power of two in the normal range.
      */
     static float powerOfTwoF(int n) {
-        return Float.intBitsToFloat(((n + FloatConsts.MAX_EXPONENT) <<
+        return Float.intBitsToFloat(((n + Float.MAX_EXPONENT) <<
                                      (FloatConsts.SIGNIFICAND_WIDTH-1))
                                     & FloatConsts.EXP_BIT_MASK);
     }
@@ -129,7 +126,7 @@
                                   +16.0f,
                                   +Float.MIN_VALUE,
                                   +Float_MAX_SUBNORMAL,
-                                  +FloatConsts.MIN_NORMAL,
+                                  +Float.MIN_NORMAL,
                                   +Float.MAX_VALUE
         };
 
@@ -139,10 +136,10 @@
                                  0,
                                  1,
                                  4,
-                                 FloatConsts.MIN_EXPONENT - 1,
-                                 -FloatConsts.MAX_EXPONENT,
-                                 FloatConsts.MIN_EXPONENT,
-                                 FloatConsts.MAX_EXPONENT
+                                 Float.MIN_EXPONENT - 1,
+                                 -Float.MAX_EXPONENT,
+                                 Float.MIN_EXPONENT,
+                                 Float.MAX_EXPONENT
         };
 
         // Special value tests
@@ -152,7 +149,7 @@
 
 
         // Normal exponent tests
-        for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
+        for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
             int result;
 
             // Create power of two
@@ -175,7 +172,7 @@
                 failures += testGetExponentCase(randFloat, i);
             }
 
-            if (i > FloatConsts.MIN_EXPONENT) {
+            if (i > Float.MIN_EXPONENT) {
                 float po2minus = Math.nextAfter(po2,
                                                  Float.NEGATIVE_INFINITY);
                 failures += testGetExponentCase(po2minus, i-1);
@@ -199,13 +196,13 @@
             i++, top *= 2.0f) {
 
             failures += testGetExponentCase(top,
-                                            FloatConsts.MIN_EXPONENT - 1);
+                                            Float.MIN_EXPONENT - 1);
 
             // Test largest value in next smaller binade
             if (i >= 3) {// (i == 1) would test 0.0;
                          // (i == 2) would just retest MIN_VALUE
                 testGetExponentCase(Math.nextAfter(top, 0.0f),
-                                    FloatConsts.MIN_EXPONENT - 1);
+                                    Float.MIN_EXPONENT - 1);
 
                 if( i >= 10) {
                     // create a bit mask with (i-1) 1's in the low order
@@ -217,7 +214,7 @@
                                                  (rand.nextInt() & mask ) ) ;
 
                     failures += testGetExponentCase(randFloat,
-                                                    FloatConsts.MIN_EXPONENT - 1);
+                                                    Float.MIN_EXPONENT - 1);
                 }
             }
         }
@@ -236,7 +233,7 @@
                                    +16.0,
                                    +Double.MIN_VALUE,
                                    +Double_MAX_SUBNORMAL,
-                                   +DoubleConsts.MIN_NORMAL,
+                                   +Double.MIN_NORMAL,
                                    +Double.MAX_VALUE
         };
 
@@ -246,10 +243,10 @@
                                  0,
                                  1,
                                  4,
-                                 DoubleConsts.MIN_EXPONENT - 1,
-                                 -DoubleConsts.MAX_EXPONENT,
-                                 DoubleConsts.MIN_EXPONENT,
-                                 DoubleConsts.MAX_EXPONENT
+                                 Double.MIN_EXPONENT - 1,
+                                 -Double.MAX_EXPONENT,
+                                 Double.MIN_EXPONENT,
+                                 Double.MAX_EXPONENT
         };
 
         // Special value tests
@@ -259,7 +256,7 @@
 
 
         // Normal exponent tests
-        for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
             int result;
 
             // Create power of two
@@ -282,7 +279,7 @@
                 failures += testGetExponentCase(randFloat, i);
             }
 
-            if (i > DoubleConsts.MIN_EXPONENT) {
+            if (i > Double.MIN_EXPONENT) {
                 double po2minus = Math.nextAfter(po2,
                                                     Double.NEGATIVE_INFINITY);
                 failures += testGetExponentCase(po2minus, i-1);
@@ -306,13 +303,13 @@
             i++, top *= 2.0f) {
 
             failures += testGetExponentCase(top,
-                                            DoubleConsts.MIN_EXPONENT - 1);
+                                            Double.MIN_EXPONENT - 1);
 
             // Test largest value in next smaller binade
             if (i >= 3) {// (i == 1) would test 0.0;
                          // (i == 2) would just retest MIN_VALUE
                 testGetExponentCase(Math.nextAfter(top, 0.0),
-                                    DoubleConsts.MIN_EXPONENT - 1);
+                                    Double.MIN_EXPONENT - 1);
 
                 if( i >= 10) {
                     // create a bit mask with (i-1) 1's in the low order
@@ -324,7 +321,7 @@
                                                  (rand.nextLong() & mask ) ) ;
 
                     failures += testGetExponentCase(randFloat,
-                                                    DoubleConsts.MIN_EXPONENT - 1);
+                                                    Double.MIN_EXPONENT - 1);
                 }
             }
         }
@@ -400,15 +397,15 @@
             {Float_MAX_VALUEmm, infinityF,              Float.MAX_VALUE},
             {Float_MAX_VALUEmm, Float_MAX_VALUEmm,      Float_MAX_VALUEmm},
 
-            {FloatConsts.MIN_NORMAL,    infinityF,              FloatConsts.MIN_NORMAL+
+            {Float.MIN_NORMAL,          infinityF,              Float.MIN_NORMAL+
                                                                 Float.MIN_VALUE},
-            {FloatConsts.MIN_NORMAL,    -infinityF,             Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL,    1.0f,                   FloatConsts.MIN_NORMAL+
+            {Float.MIN_NORMAL,          -infinityF,             Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL,          1.0f,                   Float.MIN_NORMAL+
                                                                 Float.MIN_VALUE},
-            {FloatConsts.MIN_NORMAL,    -1.0f,                  Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL,    FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
+            {Float.MIN_NORMAL,          -1.0f,                  Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL,          Float.MIN_NORMAL,       Float.MIN_NORMAL},
 
-            {Float_MAX_SUBNORMAL,       FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
+            {Float_MAX_SUBNORMAL,       Float.MIN_NORMAL,       Float.MIN_NORMAL},
             {Float_MAX_SUBNORMAL,       Float_MAX_SUBNORMAL,    Float_MAX_SUBNORMAL},
             {Float_MAX_SUBNORMAL,       0.0f,                   Float_MAX_SUBNORMALmm},
 
@@ -472,15 +469,15 @@
             {Double_MAX_VALUEmm,        infinityD,              Double.MAX_VALUE},
             {Double_MAX_VALUEmm,        Double_MAX_VALUEmm,     Double_MAX_VALUEmm},
 
-            {DoubleConsts.MIN_NORMAL,   infinityD,              DoubleConsts.MIN_NORMAL+
+            {Double.MIN_NORMAL,         infinityD,              Double.MIN_NORMAL+
                                                                 Double.MIN_VALUE},
-            {DoubleConsts.MIN_NORMAL,   -infinityD,             Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL,   1.0f,                   DoubleConsts.MIN_NORMAL+
+            {Double.MIN_NORMAL,         -infinityD,             Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL,         1.0f,                   Double.MIN_NORMAL+
                                                                 Double.MIN_VALUE},
-            {DoubleConsts.MIN_NORMAL,   -1.0f,                  Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL,   DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
+            {Double.MIN_NORMAL,         -1.0f,                  Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL,         Double.MIN_NORMAL,      Double.MIN_NORMAL},
 
-            {Double_MAX_SUBNORMAL,      DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
+            {Double_MAX_SUBNORMAL,      Double.MIN_NORMAL,      Double.MIN_NORMAL},
             {Double_MAX_SUBNORMAL,      Double_MAX_SUBNORMAL,   Double_MAX_SUBNORMAL},
             {Double_MAX_SUBNORMAL,      0.0d,                   Double_MAX_SUBNORMALmm},
 
@@ -529,15 +526,15 @@
             {NaNf,                      NaNf},
             {-infinityF,                -Float.MAX_VALUE},
             {-Float.MAX_VALUE,          -Float_MAX_VALUEmm},
-            {-FloatConsts.MIN_NORMAL,   -Float_MAX_SUBNORMAL},
+            {-Float.MIN_NORMAL,         -Float_MAX_SUBNORMAL},
             {-Float_MAX_SUBNORMAL,      -Float_MAX_SUBNORMALmm},
             {-Float.MIN_VALUE,          -0.0f},
             {-0.0f,                     Float.MIN_VALUE},
             {+0.0f,                     Float.MIN_VALUE},
             {Float.MIN_VALUE,           Float.MIN_VALUE*2},
             {Float_MAX_SUBNORMALmm,     Float_MAX_SUBNORMAL},
-            {Float_MAX_SUBNORMAL,       FloatConsts.MIN_NORMAL},
-            {FloatConsts.MIN_NORMAL,    FloatConsts.MIN_NORMAL+Float.MIN_VALUE},
+            {Float_MAX_SUBNORMAL,       Float.MIN_NORMAL},
+            {Float.MIN_NORMAL,          Float.MIN_NORMAL+Float.MIN_VALUE},
             {Float_MAX_VALUEmm,         Float.MAX_VALUE},
             {Float.MAX_VALUE,           infinityF},
             {infinityF,                 infinityF}
@@ -567,15 +564,15 @@
             {NaNd,                      NaNd},
             {-infinityD,                -Double.MAX_VALUE},
             {-Double.MAX_VALUE,         -Double_MAX_VALUEmm},
-            {-DoubleConsts.MIN_NORMAL,  -Double_MAX_SUBNORMAL},
+            {-Double.MIN_NORMAL,        -Double_MAX_SUBNORMAL},
             {-Double_MAX_SUBNORMAL,     -Double_MAX_SUBNORMALmm},
             {-Double.MIN_VALUE,         -0.0d},
             {-0.0d,                     Double.MIN_VALUE},
             {+0.0d,                     Double.MIN_VALUE},
             {Double.MIN_VALUE,          Double.MIN_VALUE*2},
             {Double_MAX_SUBNORMALmm,    Double_MAX_SUBNORMAL},
-            {Double_MAX_SUBNORMAL,      DoubleConsts.MIN_NORMAL},
-            {DoubleConsts.MIN_NORMAL,   DoubleConsts.MIN_NORMAL+Double.MIN_VALUE},
+            {Double_MAX_SUBNORMAL,      Double.MIN_NORMAL},
+            {Double.MIN_NORMAL,         Double.MIN_NORMAL+Double.MIN_VALUE},
             {Double_MAX_VALUEmm,        Double.MAX_VALUE},
             {Double.MAX_VALUE,          infinityD},
             {infinityD,                 infinityD}
@@ -607,16 +604,16 @@
             {-infinityF,                -infinityF},
             {-Float.MAX_VALUE,          -infinityF},
             {-Float_MAX_VALUEmm,        -Float.MAX_VALUE},
-            {-Float_MAX_SUBNORMAL,      -FloatConsts.MIN_NORMAL},
+            {-Float_MAX_SUBNORMAL,      -Float.MIN_NORMAL},
             {-Float_MAX_SUBNORMALmm,    -Float_MAX_SUBNORMAL},
             {-0.0f,                     -Float.MIN_VALUE},
             {+0.0f,                     -Float.MIN_VALUE},
             {Float.MIN_VALUE,           0.0f},
             {Float.MIN_VALUE*2,         Float.MIN_VALUE},
             {Float_MAX_SUBNORMAL,       Float_MAX_SUBNORMALmm},
-            {FloatConsts.MIN_NORMAL,    Float_MAX_SUBNORMAL},
-            {FloatConsts.MIN_NORMAL+
-             Float.MIN_VALUE,           FloatConsts.MIN_NORMAL},
+            {Float.MIN_NORMAL,          Float_MAX_SUBNORMAL},
+            {Float.MIN_NORMAL+
+             Float.MIN_VALUE,           Float.MIN_NORMAL},
             {Float.MAX_VALUE,           Float_MAX_VALUEmm},
             {infinityF,                 Float.MAX_VALUE},
         };
@@ -646,16 +643,16 @@
             {-infinityD,                -infinityD},
             {-Double.MAX_VALUE,         -infinityD},
             {-Double_MAX_VALUEmm,       -Double.MAX_VALUE},
-            {-Double_MAX_SUBNORMAL,     -DoubleConsts.MIN_NORMAL},
+            {-Double_MAX_SUBNORMAL,     -Double.MIN_NORMAL},
             {-Double_MAX_SUBNORMALmm,   -Double_MAX_SUBNORMAL},
             {-0.0d,                     -Double.MIN_VALUE},
             {+0.0d,                     -Double.MIN_VALUE},
             {Double.MIN_VALUE,          0.0d},
             {Double.MIN_VALUE*2,        Double.MIN_VALUE},
             {Double_MAX_SUBNORMAL,      Double_MAX_SUBNORMALmm},
-            {DoubleConsts.MIN_NORMAL,   Double_MAX_SUBNORMAL},
-            {DoubleConsts.MIN_NORMAL+
-             Double.MIN_VALUE,          DoubleConsts.MIN_NORMAL},
+            {Double.MIN_NORMAL,         Double_MAX_SUBNORMAL},
+            {Double.MIN_NORMAL+
+             Double.MIN_VALUE,          Double.MIN_NORMAL},
             {Double.MAX_VALUE,          Double_MAX_VALUEmm},
             {infinityD,                 Double.MAX_VALUE},
         };
@@ -689,7 +686,7 @@
             -Float.MAX_VALUE,
             -3.0f,
             -1.0f,
-            -FloatConsts.MIN_NORMAL,
+            -Float.MIN_NORMAL,
             -Float_MAX_SUBNORMALmm,
             -Float_MAX_SUBNORMAL,
             -Float.MIN_VALUE,
@@ -698,7 +695,7 @@
             Float.MIN_VALUE,
             Float_MAX_SUBNORMALmm,
             Float_MAX_SUBNORMAL,
-            FloatConsts.MIN_NORMAL,
+            Float.MIN_NORMAL,
             1.0f,
             3.0f,
             Float_MAX_VALUEmm,
@@ -739,7 +736,7 @@
             -Double.MAX_VALUE,
             -3.0d,
             -1.0d,
-            -DoubleConsts.MIN_NORMAL,
+            -Double.MIN_NORMAL,
             -Double_MAX_SUBNORMALmm,
             -Double_MAX_SUBNORMAL,
             -Double.MIN_VALUE,
@@ -748,7 +745,7 @@
             Double.MIN_VALUE,
             Double_MAX_SUBNORMALmm,
             Double_MAX_SUBNORMAL,
-            DoubleConsts.MIN_NORMAL,
+            Double.MIN_NORMAL,
             1.0d,
             3.0d,
             Double_MAX_VALUEmm,
@@ -790,7 +787,7 @@
              Float.MIN_VALUE,
              Float_MAX_SUBNORMALmm,
              Float_MAX_SUBNORMAL,
-             FloatConsts.MIN_NORMAL,
+             Float.MIN_NORMAL,
              1.0f,
              3.0f,
              Float_MAX_VALUEmm,
@@ -801,7 +798,7 @@
              -Float.MAX_VALUE,
              -3.0f,
              -1.0f,
-             -FloatConsts.MIN_NORMAL,
+             -Float.MIN_NORMAL,
              -Float_MAX_SUBNORMALmm,
              -Float_MAX_SUBNORMAL,
              -Float.MIN_VALUE,
@@ -864,7 +861,7 @@
              Double.MIN_VALUE,
              Double_MAX_SUBNORMALmm,
              Double_MAX_SUBNORMAL,
-             DoubleConsts.MIN_NORMAL,
+             Double.MIN_NORMAL,
              1.0d,
              3.0d,
              Double_MAX_VALUEmm,
@@ -875,7 +872,7 @@
              -Double.MAX_VALUE,
              -3.0d,
              -1.0d,
-             -DoubleConsts.MIN_NORMAL,
+             -Double.MIN_NORMAL,
              -Double_MAX_SUBNORMALmm,
              -Double_MAX_SUBNORMAL,
              -Double.MIN_VALUE,
@@ -964,7 +961,7 @@
 
     public static int testFloatScalb() {
         int failures=0;
-        int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT +
+        int MAX_SCALE = Float.MAX_EXPONENT + -Float.MIN_EXPONENT +
                         FloatConsts.SIGNIFICAND_WIDTH + 1;
 
 
@@ -988,7 +985,7 @@
             3.0f*Float.MIN_VALUE,
             Float_MAX_SUBNORMALmm,
             Float_MAX_SUBNORMAL,
-            FloatConsts.MIN_NORMAL,
+            Float.MIN_NORMAL,
             1.0f,
             2.0f,
             3.0f,
@@ -998,8 +995,8 @@
         };
 
         int [] oneMultiplyScalingFactors = {
-            FloatConsts.MIN_EXPONENT,
-            FloatConsts.MIN_EXPONENT+1,
+            Float.MIN_EXPONENT,
+            Float.MIN_EXPONENT+1,
             -3,
             -2,
             -1,
@@ -1007,8 +1004,8 @@
             1,
             2,
             3,
-            FloatConsts.MAX_EXPONENT-1,
-            FloatConsts.MAX_EXPONENT
+            Float.MAX_EXPONENT-1,
+            Float.MAX_EXPONENT
         };
 
         int [] manyScalingFactors = {
@@ -1018,14 +1015,14 @@
             -MAX_SCALE,
             -MAX_SCALE+1,
 
-            2*FloatConsts.MIN_EXPONENT-1,       // -253
-            2*FloatConsts.MIN_EXPONENT,         // -252
-            2*FloatConsts.MIN_EXPONENT+1,       // -251
+            2*Float.MIN_EXPONENT-1,       // -253
+            2*Float.MIN_EXPONENT,         // -252
+            2*Float.MIN_EXPONENT+1,       // -251
 
-            FloatConsts.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
+            Float.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
             FloatConsts.MIN_SUB_EXPONENT,
-            -FloatConsts.MAX_EXPONENT,          // -127
-            FloatConsts.MIN_EXPONENT,           // -126
+            -Float.MAX_EXPONENT,          // -127
+            Float.MIN_EXPONENT,           // -126
 
             -2,
             -1,
@@ -1033,13 +1030,13 @@
             1,
             2,
 
-            FloatConsts.MAX_EXPONENT-1,         // 126
-            FloatConsts.MAX_EXPONENT,           // 127
-            FloatConsts.MAX_EXPONENT+1,         // 128
+            Float.MAX_EXPONENT-1,         // 126
+            Float.MAX_EXPONENT,           // 127
+            Float.MAX_EXPONENT+1,         // 128
 
-            2*FloatConsts.MAX_EXPONENT-1,       // 253
-            2*FloatConsts.MAX_EXPONENT,         // 254
-            2*FloatConsts.MAX_EXPONENT+1,       // 255
+            2*Float.MAX_EXPONENT-1,       // 253
+            2*Float.MAX_EXPONENT,         // 254
+            2*Float.MAX_EXPONENT+1,       // 255
 
             MAX_SCALE-1,
             MAX_SCALE,
@@ -1086,7 +1083,7 @@
 
         // Create 2^MAX_EXPONENT
         float twoToTheMaxExp = 1.0f; // 2^0
-        for(int i = 0; i < FloatConsts.MAX_EXPONENT; i++)
+        for(int i = 0; i < Float.MAX_EXPONENT; i++)
             twoToTheMaxExp *=2.0f;
 
         // Scale-up subnormal values until they all overflow
@@ -1094,12 +1091,12 @@
             float scale = 1.0f; // 2^j
             float value = subnormalTestCases[i];
 
-            for(int j=FloatConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
+            for(int j=Float.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
                 int scaleFactor = j;
 
                 failures+=testScalbCase(value,
                                         scaleFactor,
-                                        (Tests.ilogb(value) +j > FloatConsts.MAX_EXPONENT ) ?
+                                        (Tests.ilogb(value) +j > Float.MAX_EXPONENT ) ?
                                         Math.copySign(infinityF, value) : // overflow
                                         // calculate right answer
                                         twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
@@ -1172,7 +1169,7 @@
 
     public static int testDoubleScalb() {
         int failures=0;
-        int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT +
+        int MAX_SCALE = Double.MAX_EXPONENT + -Double.MIN_EXPONENT +
                         DoubleConsts.SIGNIFICAND_WIDTH + 1;
 
 
@@ -1195,7 +1192,7 @@
             3.0d*Double.MIN_VALUE,
             Double_MAX_SUBNORMALmm,
             Double_MAX_SUBNORMAL,
-            DoubleConsts.MIN_NORMAL,
+            Double.MIN_NORMAL,
             1.0d,
             2.0d,
             3.0d,
@@ -1205,8 +1202,8 @@
         };
 
         int [] oneMultiplyScalingFactors = {
-            DoubleConsts.MIN_EXPONENT,
-            DoubleConsts.MIN_EXPONENT+1,
+            Double.MIN_EXPONENT,
+            Double.MIN_EXPONENT+1,
             -3,
             -2,
             -1,
@@ -1214,8 +1211,8 @@
             1,
             2,
             3,
-            DoubleConsts.MAX_EXPONENT-1,
-            DoubleConsts.MAX_EXPONENT
+            Double.MAX_EXPONENT-1,
+            Double.MAX_EXPONENT
         };
 
         int [] manyScalingFactors = {
@@ -1225,15 +1222,15 @@
             -MAX_SCALE,
             -MAX_SCALE+1,
 
-            2*DoubleConsts.MIN_EXPONENT-1,      // -2045
-            2*DoubleConsts.MIN_EXPONENT,        // -2044
-            2*DoubleConsts.MIN_EXPONENT+1,      // -2043
+            2*Double.MIN_EXPONENT-1,      // -2045
+            2*Double.MIN_EXPONENT,        // -2044
+            2*Double.MIN_EXPONENT+1,      // -2043
 
-            DoubleConsts.MIN_EXPONENT,          // -1022
-            DoubleConsts.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
+            Double.MIN_EXPONENT,          // -1022
+            Double.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
             DoubleConsts.MIN_SUB_EXPONENT,
-            -DoubleConsts.MAX_EXPONENT,         // -1023
-            DoubleConsts.MIN_EXPONENT,          // -1022
+            -Double.MAX_EXPONENT,         // -1023
+            Double.MIN_EXPONENT,          // -1022
 
             -2,
             -1,
@@ -1241,13 +1238,13 @@
             1,
             2,
 
-            DoubleConsts.MAX_EXPONENT-1,        // 1022
-            DoubleConsts.MAX_EXPONENT,          // 1023
-            DoubleConsts.MAX_EXPONENT+1,        // 1024
+            Double.MAX_EXPONENT-1,        // 1022
+            Double.MAX_EXPONENT,          // 1023
+            Double.MAX_EXPONENT+1,        // 1024
 
-            2*DoubleConsts.MAX_EXPONENT-1,      // 2045
-            2*DoubleConsts.MAX_EXPONENT,        // 2046
-            2*DoubleConsts.MAX_EXPONENT+1,      // 2047
+            2*Double.MAX_EXPONENT-1,      // 2045
+            2*Double.MAX_EXPONENT,        // 2046
+            2*Double.MAX_EXPONENT+1,      // 2047
 
             MAX_SCALE-1,
             MAX_SCALE,
@@ -1294,7 +1291,7 @@
 
         // Create 2^MAX_EXPONENT
         double twoToTheMaxExp = 1.0; // 2^0
-        for(int i = 0; i < DoubleConsts.MAX_EXPONENT; i++)
+        for(int i = 0; i < Double.MAX_EXPONENT; i++)
             twoToTheMaxExp *=2.0;
 
         // Scale-up subnormal values until they all overflow
@@ -1302,12 +1299,12 @@
             double scale = 1.0; // 2^j
             double value = subnormalTestCases[i];
 
-            for(int j=DoubleConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
+            for(int j=Double.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
                 int scaleFactor = j;
 
                 failures+=testScalbCase(value,
                                         scaleFactor,
-                                        (Tests.ilogb(value) +j > DoubleConsts.MAX_EXPONENT ) ?
+                                        (Tests.ilogb(value) +j > Double.MAX_EXPONENT ) ?
                                         Math.copySign(infinityD, value) : // overflow
                                         // calculate right answer
                                         twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
@@ -1345,7 +1342,7 @@
 
         double value = 0x1.000000000000bP-1;
         expected     = 0x0.2000000000001P-1022;
-        for(int i = 0; i < DoubleConsts.MAX_EXPONENT+2; i++) {
+        for(int i = 0; i < Double.MAX_EXPONENT+2; i++) {
             failures+=testScalbCase(value,
                                     -1024-i,
                                     expected);
@@ -1401,7 +1398,7 @@
                                   +16.0f,
                                   +Float.MIN_VALUE,
                                   +Float_MAX_SUBNORMAL,
-                                  +FloatConsts.MIN_NORMAL,
+                                  +Float.MIN_NORMAL,
                                   +Float.MAX_VALUE
         };
 
@@ -1424,7 +1421,7 @@
 
 
         // Normal exponent tests
-        for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
+        for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
             float expected;
 
             // Create power of two
@@ -1448,7 +1445,7 @@
                 failures += testUlpCase(randFloat, expected);
             }
 
-            if (i > FloatConsts.MIN_EXPONENT) {
+            if (i > Float.MIN_EXPONENT) {
                 float po2minus = Math.nextAfter(po2,
                                                    Float.NEGATIVE_INFINITY);
                 failures += testUlpCase(po2minus, expected/2.0f);
@@ -1506,7 +1503,7 @@
                                   +16.0d,
                                   +Double.MIN_VALUE,
                                   +Double_MAX_SUBNORMAL,
-                                  +DoubleConsts.MIN_NORMAL,
+                                  +Double.MIN_NORMAL,
                                   +Double.MAX_VALUE
         };
 
@@ -1529,7 +1526,7 @@
 
 
         // Normal exponent tests
-        for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
             double expected;
 
             // Create power of two
@@ -1553,7 +1550,7 @@
                 failures += testUlpCase(randDouble, expected);
             }
 
-            if (i > DoubleConsts.MIN_EXPONENT) {
+            if (i > Double.MIN_EXPONENT) {
                 double po2minus = Math.nextAfter(po2,
                                                     Double.NEGATIVE_INFINITY);
                 failures += testUlpCase(po2minus, expected/2.0f);
@@ -1607,7 +1604,7 @@
             {NaNf,                      NaNf},
             {-infinityF,                -1.0f},
             {-Float.MAX_VALUE,          -1.0f},
-            {-FloatConsts.MIN_NORMAL,   -1.0f},
+            {-Float.MIN_NORMAL,         -1.0f},
             {-1.0f,                     -1.0f},
             {-2.0f,                     -1.0f},
             {-Float_MAX_SUBNORMAL,      -1.0f},
@@ -1617,7 +1614,7 @@
             {Float.MIN_VALUE,            1.0f},
             {Float_MAX_SUBNORMALmm,      1.0f},
             {Float_MAX_SUBNORMAL,        1.0f},
-            {FloatConsts.MIN_NORMAL,     1.0f},
+            {Float.MIN_NORMAL,           1.0f},
             {1.0f,                       1.0f},
             {2.0f,                       1.0f},
             {Float_MAX_VALUEmm,          1.0f},
@@ -1641,7 +1638,7 @@
             {NaNd,                      NaNd},
             {-infinityD,                -1.0},
             {-Double.MAX_VALUE,         -1.0},
-            {-DoubleConsts.MIN_NORMAL,  -1.0},
+            {-Double.MIN_NORMAL,        -1.0},
             {-1.0,                      -1.0},
             {-2.0,                      -1.0},
             {-Double_MAX_SUBNORMAL,     -1.0},
@@ -1651,7 +1648,7 @@
             {Double.MIN_VALUE,           1.0},
             {Double_MAX_SUBNORMALmm,     1.0},
             {Double_MAX_SUBNORMAL,       1.0},
-            {DoubleConsts.MIN_NORMAL,    1.0},
+            {Double.MIN_NORMAL,          1.0},
             {1.0,                        1.0},
             {2.0,                        1.0},
             {Double_MAX_VALUEmm,         1.0},

--- a/jdk/test/java/lang/Math/Log10Tests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/Log10Tests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 public class Log10Tests {
     private Log10Tests(){}
 
@@ -70,7 +68,7 @@
             {Double.NEGATIVE_INFINITY,  NaNd},
             {-8.0,                      NaNd},
             {-1.0,                      NaNd},
-            {-DoubleConsts.MIN_NORMAL,  NaNd},
+            {-Double.MIN_NORMAL,        NaNd},
             {-Double.MIN_VALUE,         NaNd},
             {-0.0,                      -infinityD},
             {+0.0,                      -infinityD},

--- a/jdk/test/java/lang/Math/Log1pTests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/Log1pTests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -28,8 +28,6 @@
  * @author Joseph D. Darcy
  */
 
-import sun.misc.DoubleConsts;
-
 public class Log1pTests {
     private Log1pTests(){}
 
@@ -93,7 +91,7 @@
         }
 
         // For x > 2^53 log1p(x) ~= log(x)
-        for(int i = 53; i <= DoubleConsts.MAX_EXPONENT; i++) {
+        for(int i = 53; i <= Double.MAX_EXPONENT; i++) {
             double d = Math.scalb(2, i);
             failures += testLog1pCaseWithUlpDiff(d, StrictMath.log(d), 2.001);
         }

--- a/jdk/test/java/lang/Math/Rint.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/Rint.java	Fri Aug 22 14:56:09 2014 -0700
@@ -27,8 +27,6 @@
  * @summary Check for correct implementation of Math.rint(double)
  */
 
-import sun.misc.DoubleConsts;
-
 public class Rint {
 
     static int testRintCase(double input, double expected) {
@@ -51,8 +49,8 @@
         double [][] testCases = {
             {0.0,                               0.0},
             {Double.MIN_VALUE,                  0.0},
-            {Math.nextDown(DoubleConsts.MIN_NORMAL), 0.0},
-            {DoubleConsts.MIN_NORMAL,           0.0},
+            {Math.nextDown(Double.MIN_NORMAL),  0.0},
+            {Double.MIN_NORMAL,                 0.0},
 
             {0.2,                               0.0},
 

--- a/jdk/test/java/lang/Math/Tests.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/lang/Math/Tests.java	Fri Aug 22 14:56:09 2014 -0700
@@ -30,9 +30,6 @@
  * and finally the expected result.
  */
 
-import sun.misc.FloatConsts;
-import sun.misc.DoubleConsts;
-
 public class Tests {
     private Tests(){}; // do not instantiate
 
@@ -81,13 +78,13 @@
         int exponent = Math.getExponent(d);
 
         switch (exponent) {
-        case DoubleConsts.MAX_EXPONENT+1:       // NaN or infinity
+        case Double.MAX_EXPONENT+1:       // NaN or infinity
             if( Double.isNaN(d) )
                 return (1<<30);         // 2^30
             else // infinite value
                 return (1<<28);         // 2^28
 
-        case DoubleConsts.MIN_EXPONENT-1:       // zero or subnormal
+        case Double.MIN_EXPONENT-1:       // zero or subnormal
             if(d == 0.0) {
                 return -(1<<28);        // -(2^28)
             }
@@ -117,14 +114,14 @@
                 }
                 exponent++;
                 assert( exponent >=
-                        DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
-                        exponent < DoubleConsts.MIN_EXPONENT);
+                        Double.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
+                        exponent < Double.MIN_EXPONENT);
                 return exponent;
             }
 
         default:
-            assert( exponent >= DoubleConsts.MIN_EXPONENT &&
-                    exponent <= DoubleConsts.MAX_EXPONENT);
+            assert( exponent >= Double.MIN_EXPONENT &&
+                    exponent <= Double.MAX_EXPONENT);
             return exponent;
         }
     }
@@ -150,13 +147,13 @@
         int exponent = Math.getExponent(f);
 
         switch (exponent) {
-        case FloatConsts.MAX_EXPONENT+1:        // NaN or infinity
+        case Float.MAX_EXPONENT+1:        // NaN or infinity
             if( Float.isNaN(f) )
                 return (1<<30);         // 2^30
             else // infinite value
                 return (1<<28);         // 2^28
 
-        case FloatConsts.MIN_EXPONENT-1:        // zero or subnormal
+        case Float.MIN_EXPONENT-1:        // zero or subnormal
             if(f == 0.0f) {
                 return -(1<<28);        // -(2^28)
             }
@@ -186,14 +183,14 @@
                 }
                 exponent++;
                 assert( exponent >=
-                        FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
-                        exponent < FloatConsts.MIN_EXPONENT);
+                        Float.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
+                        exponent < Float.MIN_EXPONENT);
                 return exponent;
             }
 
         default:
-            assert( exponent >= FloatConsts.MIN_EXPONENT &&
-                    exponent <= FloatConsts.MAX_EXPONENT);
+            assert( exponent >= Float.MIN_EXPONENT &&
+                    exponent <= Float.MAX_EXPONENT);
             return exponent;
         }
     }

--- a/jdk/test/java/util/Formatter/BasicDouble.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/java/util/Formatter/BasicDouble.java	Fri Aug 22 14:56:09 2014 -0700
@@ -36,9 +36,6 @@
 import java.text.DateFormatSymbols;
 import java.util.*;
 
-import sun.misc.DoubleConsts;
-
-
 import static java.util.Calendar.*;
 
 
@@ -1313,12 +1310,12 @@
         test("%.1a", "-0x1.0p0", -1.0);
         test("%.11a", "0x1.80000000000p1", 3.0);
         test("%.1a", "0x1.8p1", 3.0);
-        test("%.11a", "0x1.00000000000p-1022", DoubleConsts.MIN_NORMAL);
-        test("%.1a", "0x1.0p-1022", DoubleConsts.MIN_NORMAL);
+        test("%.11a", "0x1.00000000000p-1022", Double.MIN_NORMAL);
+        test("%.1a", "0x1.0p-1022", Double.MIN_NORMAL);
         test("%.11a", "0x1.00000000000p-1022",
-             Math.nextDown(DoubleConsts.MIN_NORMAL));
+             Math.nextDown(Double.MIN_NORMAL));
         test("%.1a", "0x1.0p-1022",
-             Math.nextDown(DoubleConsts.MIN_NORMAL));
+             Math.nextDown(Double.MIN_NORMAL));
         test("%.11a", "0x1.ffffffffffep-1023", 0x0.fffffffffffp-1022);
         test("%.1a", "0x1.0p-1022", 0x0.fffffffffffp-1022);
         test("%.30a", "0x0.000000000000100000000000000000p-1022", Double.MIN_VALUE);

--- a/jdk/test/sun/misc/FloatingDecimal/OldFloatingDecimalForTest.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/sun/misc/FloatingDecimal/OldFloatingDecimalForTest.java	Fri Aug 22 14:56:09 2014 -0700
@@ -23,8 +23,6 @@
 
 //package sun.misc;
 
-import sun.misc.DoubleConsts;
-import sun.misc.FloatConsts;
 import java.util.regex.*;
 
 public class OldFloatingDecimalForTest{
@@ -2217,12 +2215,12 @@
 
             // Check for overflow and update exponent accordingly.
 
-            if (exponent > DoubleConsts.MAX_EXPONENT) {         // Infinite result
+            if (exponent > Double.MAX_EXPONENT) {         // Infinite result
                 // overflow to properly signed infinity
                 return new OldFloatingDecimalForTest(sign * Double.POSITIVE_INFINITY);
             } else {  // Finite return value
-                if (exponent <= DoubleConsts.MAX_EXPONENT && // (Usually) normal result
-                    exponent >= DoubleConsts.MIN_EXPONENT) {
+                if (exponent <= Double.MAX_EXPONENT && // (Usually) normal result
+                    exponent >= Double.MIN_EXPONENT) {
 
                     // The result returned in this block cannot be a
                     // zero or subnormal; however after the
@@ -2242,7 +2240,7 @@
                         (DoubleConsts.SIGNIF_BIT_MASK & significand);
 
                 }  else  {  // Subnormal or zero
-                    // (exponent < DoubleConsts.MIN_EXPONENT)
+                    // (exponent < Double.MIN_EXPONENT)
 
                     if (exponent < (DoubleConsts.MIN_SUB_EXPONENT -1 )) {
                         // No way to round back to nonzero value
@@ -2282,7 +2280,7 @@
                         // Now, discard the bits
                         significand = significand >> bitsDiscarded;
 
-                        significand = (( ((long)(DoubleConsts.MIN_EXPONENT -1) + // subnorm exp.
+                        significand = (( ((long)(Double.MIN_EXPONENT -1) + // subnorm exp.
                                           (long)DoubleConsts.EXP_BIAS) <<
                                          (DoubleConsts.SIGNIFICAND_WIDTH-1))
                                        & DoubleConsts.EXP_BIT_MASK) |
@@ -2350,7 +2348,7 @@
                  * information must be preserved (i.e. case 1).
                  */
                 if ((exponent >= FloatConsts.MIN_SUB_EXPONENT-1) &&
-                    (exponent <= FloatConsts.MAX_EXPONENT ) ){
+                    (exponent <= Float.MAX_EXPONENT ) ){
                     // Outside above exponent range, the float value
                     // will be zero or infinity.
 

--- a/jdk/test/sun/misc/FloatingDecimal/TestFloatingDecimal.java	Sat Aug 23 01:05:50 2014 +0400
+++ b/jdk/test/sun/misc/FloatingDecimal/TestFloatingDecimal.java	Fri Aug 22 14:56:09 2014 -0700
@@ -58,6 +58,9 @@
  * @test
  * @bug 7032154
  * @summary unit tests of sun.misc.FloatingDecimal
+ * @library ../../../java/lang/Math
+ * @build DoubleConsts FloatConsts
+ * @run main TestFloatingDecimal
  * @author Brian Burkhalter
  */
 public class TestFloatingDecimal {