diff --git a/dev/core/test/com/google/gwt/dev/CompilerTest.java b/dev/core/test/com/google/gwt/dev/CompilerTest.java
index 308973d..239a2f9 100644
--- a/dev/core/test/com/google/gwt/dev/CompilerTest.java
+++ b/dev/core/test/com/google/gwt/dev/CompilerTest.java
@@ -39,13 +39,13 @@
 import com.google.gwt.thirdparty.guava.common.collect.Sets;
 import com.google.gwt.thirdparty.guava.common.io.Files;
 import com.google.gwt.util.tools.Utility;
-
 import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Predicate;
 import java.util.regex.Pattern;
 
 /**
@@ -2746,32 +2746,37 @@
     // List of JRE types that provide JsInterop entry points and jre native JsTypes. These are
     // always traversed fully and polute the tests, so they will be removed from stale type
     // comparisons.
-    staleTypeNames.removeAll(Arrays.asList(
-        "java.io.HasSerializableTypeMarker",
-        "java.io.Serializable",
-        "java.lang.Boolean",
-        "java.lang.CharSequence",
-        "java.lang.Cloneable",
-        "java.lang.Comparable",
-        "java.lang.Double",
-        "java.lang.HasCharSequenceTypeMarker",
-        "java.lang.HasCloneableTypeMarker",
-        "java.lang.HasComparableTypeMarker",
-        "java.lang.Integer$NativeNumber",
-        "java.lang.Number",
-        "java.lang.Number$JavaLangNumber",
-        "java.lang.String",
-        "java.lang.String$NativeFunction",
-        "java.lang.String$NativeString",
-        "java.lang.Throwable",
-        "java.lang.Throwable$HasJavaThrowable",
-        "java.lang.Throwable$NativeError",
-        "java.lang.Throwable$NativeTypeError",
-        "javaemul.internal.JsUtils",
-        "javaemul.internal.JsUtils$NativeNumber",
-        "javaemul.internal.HashCodes",
-        "javaemul.internal.NativeRegExp",
-        "javaemul.internal.NativeRegExp$Match"));
+    staleTypeNames.removeAll(
+        Arrays.asList(
+            "java.io.HasSerializableTypeMarker",
+            "java.io.Serializable",
+            "java.lang.Boolean",
+            "java.lang.CharSequence",
+            "java.lang.Cloneable",
+            "java.lang.Comparable",
+            "java.lang.Double",
+            "java.lang.HasCharSequenceTypeMarker",
+            "java.lang.HasCloneableTypeMarker",
+            "java.lang.HasComparableTypeMarker",
+            "java.lang.Integer$NativeNumber",
+            "java.lang.Number",
+            "java.lang.Number$JavaLangNumber",
+            "java.lang.String",
+            "java.lang.String$NativeFunction",
+            "java.lang.String$NativeString",
+            "java.lang.Throwable",
+            "java.lang.Throwable$HasJavaThrowable",
+            "java.lang.Throwable$NativeError",
+            "java.lang.Throwable$NativeTypeError"));
+
+    staleTypeNames.removeIf(
+        new Predicate<String>() {
+          @Override
+          public boolean test(String name) {
+            return name.startsWith("javaemul.internal");
+          }
+        });
+
     return staleTypeNames;
   }
 
diff --git a/user/super/com/google/gwt/emul/java/lang/Double.java b/user/super/com/google/gwt/emul/java/lang/Double.java
index 550c31a..8efc156 100644
--- a/user/super/com/google/gwt/emul/java/lang/Double.java
+++ b/user/super/com/google/gwt/emul/java/lang/Double.java
@@ -39,62 +39,6 @@
   public static final int BYTES = SIZE / Byte.SIZE;
   public static final Class<Double> TYPE = double.class;
 
-  // 2^512, 2^-512
-  private static final double POWER_512 = 1.3407807929942597E154;
-  private static final double POWER_MINUS_512 = 7.458340731200207E-155;
-  // 2^256, 2^-256
-  private static final double POWER_256 = 1.157920892373162E77;
-  private static final double POWER_MINUS_256 = 8.636168555094445E-78;
-  // 2^128, 2^-128
-  private static final double POWER_128 = 3.4028236692093846E38;
-  private static final double POWER_MINUS_128 = 2.9387358770557188E-39;
-  // 2^64, 2^-64
-  private static final double POWER_64 = 18446744073709551616.0;
-  private static final double POWER_MINUS_64 = 5.421010862427522E-20;
-  // 2^52, 2^-52
-  private static final double POWER_52 = 4503599627370496.0;
-  private static final double POWER_MINUS_52 = 2.220446049250313E-16;
-  // 2^32, 2^-32
-  private static final double POWER_32 = 4294967296.0;
-  private static final double POWER_MINUS_32 = 2.3283064365386963E-10;
-  // 2^31
-  private static final double POWER_31 = 2147483648.0;
-  // 2^20, 2^-20
-  private static final double POWER_20 = 1048576.0;
-  private static final double POWER_MINUS_20 = 9.5367431640625E-7;
-  // 2^16, 2^-16
-  private static final double POWER_16 = 65536.0;
-  private static final double POWER_MINUS_16 = 0.0000152587890625;
-  // 2^8, 2^-8
-  private static final double POWER_8 = 256.0;
-  private static final double POWER_MINUS_8 = 0.00390625;
-  // 2^4, 2^-4
-  private static final double POWER_4 = 16.0;
-  private static final double POWER_MINUS_4 = 0.0625;
-  // 2^2, 2^-2
-  private static final double POWER_2 = 4.0;
-  private static final double POWER_MINUS_2 = 0.25;
-  // 2^1, 2^-1
-  private static final double POWER_1 = 2.0;
-  private static final double POWER_MINUS_1 = 0.5;
-  // 2^-1022 (smallest double non-denorm)
-  private static final double POWER_MINUS_1022 = 2.2250738585072014E-308;
-
-
-
-  private static class PowersTable {
-    private static final double[] powers = {
-        POWER_512, POWER_256, POWER_128, POWER_64, POWER_32, POWER_16, POWER_8,
-        POWER_4, POWER_2, POWER_1
-    };
-
-    private static final double[] invPowers = {
-        POWER_MINUS_512, POWER_MINUS_256, POWER_MINUS_128, POWER_MINUS_64,
-        POWER_MINUS_32, POWER_MINUS_16, POWER_MINUS_8, POWER_MINUS_4, POWER_MINUS_2,
-        POWER_MINUS_1
-    };
-  }
-
   public static int compare(double x, double y) {
     if (x < y) {
       return -1;
@@ -118,82 +62,17 @@
   }
 
   public static long doubleToLongBits(double value) {
+    // Return a canonical NaN
     if (isNaN(value)) {
       return 0x7ff8000000000000L;
     }
 
-    boolean negative = false;
-    if (value == 0.0) {
-      if (1.0 / value == NEGATIVE_INFINITY) {
-        return 0x8000000000000000L; // -0.0
-      } else {
-        return 0x0L;
-      }
-    }
-    if (value < 0.0) {
-      negative = true;
-      value = -value;
-    }
-    if (isInfinite(value)) {
-      if (negative) {
-        return 0xfff0000000000000L;
-      } else {
-        return 0x7ff0000000000000L;
-      }
-    }
+    return doubleToRawLongBits(value);
+  }
 
-    int exp = 0;
-
-    // Scale d by powers of 2 into the range [1.0, 2.0)
-    // If the exponent would go below -1023, scale into (0.0, 1.0) instead
-    if (value < 1.0) {
-      int bit = 512;
-      for (int i = 0; i < 10; i++, bit >>= 1) {
-        if (value < PowersTable.invPowers[i] && exp - bit >= -1023) {
-          value *= PowersTable.powers[i];
-          exp -= bit;
-        }
-      }
-      // Force into [1.0, 2.0) range
-      if (value < 1.0 && exp - 1 >= -1023) {
-        value *= 2.0;
-        exp--;
-      }
-    } else if (value >= 2.0) {
-      int bit = 512;
-      for (int i = 0; i < 10; i++, bit >>= 1) {
-        if (value >= PowersTable.powers[i]) {
-          value *= PowersTable.invPowers[i];
-          exp += bit;
-        }
-      }
-    }
-
-    if (exp > -1023) {
-      // Remove significand of non-denormalized mantissa
-      value -= 1.0;
-    } else {
-      // Insert 0 bit as significand of denormalized mantissa
-      value *= 0.5;
-    }
-
-    // Extract high 20 bits of mantissa
-    long ihi = (long) (value * POWER_20);
-
-    // Extract low 32 bits of mantissa
-    value -= ihi * POWER_MINUS_20;
-
-    long ilo = (long) (value * POWER_52);
-
-    // Exponent bits
-    ihi |= (exp + 1023) << 20;
-
-    // Sign bit
-    if (negative) {
-      ihi |= 0x80000000L;
-    }
-
-    return (ihi << 32) | ilo;
+  // This method is kept private since it returns canonical NaN in Firefox.
+  private static long doubleToRawLongBits(double value) {
+    return JsUtils.doubleToRawLongBits(value);
   }
 
   public static int hashCode(double d) {
@@ -211,55 +90,7 @@
   public static native boolean isNaN(double x);
 
   public static double longBitsToDouble(long bits) {
-    long ihi = (long) (bits >> 32);
-    long ilo = (long) (bits & 0xffffffffL);
-    if (ihi < 0) {
-      ihi += 0x100000000L;
-    }
-    if (ilo < 0) {
-      ilo += 0x100000000L;
-    }
-
-    boolean negative = (ihi & 0x80000000) != 0;
-    int exp = (int) ((ihi >> 20) & 0x7ff);
-    ihi &= 0xfffff; // remove sign bit and exponent
-
-    if (exp == 0x0) {
-      double d = (ihi * POWER_MINUS_20) + (ilo * POWER_MINUS_52);
-      d *= POWER_MINUS_1022;
-      return negative ? (d == 0.0 ? -0.0 : -d) : d;
-    } else if (exp == 0x7ff) {
-      if (ihi == 0 && ilo == 0) {
-        return negative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
-      } else {
-        return Double.NaN;
-      }
-    }
-
-    // Normalize exponent
-    exp -= 1023;
-
-    double d = 1.0 + (ihi * POWER_MINUS_20) + (ilo * POWER_MINUS_52);
-    if (exp > 0) {
-      int bit = 512;
-      for (int i = 0; i < 10; i++, bit >>= 1) {
-        if (exp >= bit) {
-          d *= PowersTable.powers[i];
-          exp -= bit;
-        }
-      }
-    } else if (exp < 0) {
-      while (exp < 0) {
-        int bit = 512;
-        for (int i = 0; i < 10; i++, bit >>= 1) {
-          if (exp <= -bit) {
-            d *= PowersTable.invPowers[i];
-            exp += bit;
-          }
-        }
-      }
-    }
-    return negative ? -d : d;
+    return JsUtils.longBitsToDouble(bits);
   }
 
   public static double max(double a, double b) {
diff --git a/user/super/com/google/gwt/emul/java/lang/Float.java b/user/super/com/google/gwt/emul/java/lang/Float.java
index 64340d4..4e5ec5e 100644
--- a/user/super/com/google/gwt/emul/java/lang/Float.java
+++ b/user/super/com/google/gwt/emul/java/lang/Float.java
@@ -15,6 +15,8 @@
  */
 package java.lang;
 
+import javaemul.internal.JsUtils;
+
 /**
  * Wraps a primitive <code>float</code> as an object.
  */
@@ -43,46 +45,12 @@
       return 0x7fc00000;
     }
 
-    if (value == 0.0f) {
-      if (1.0 / value == NEGATIVE_INFINITY) {
-        return 0x80000000; // -0.0f
-      } else {
-        return 0x0;
-      }
-    }
-    boolean negative = false;
-    if (value < 0.0) {
-      negative = true;
-      value = -value;
-    }
-    if (isInfinite(value)) {
-      if (negative) {
-        return 0xff800000;
-      } else {
-        return 0x7f800000;
-      }
-    }
+    return floatToRawIntBits(value);
+  }
 
-    // Obtain the 64-bit representation and extract its exponent and
-    // mantissa.
-    long l = Double.doubleToLongBits((double) value);
-    int exp = (int) (((l >> 52) & 0x7ff) - 1023);
-    int mantissa = (int) ((l & 0xfffffffffffffL) >> 29);
-
-    // If the number will be a denorm in the float representation
-    // (i.e., its exponent is -127 or smaller), add a leading 1 to the
-    // mantissa and shift it right to maintain an exponent of -127.
-    if (exp <= -127) {
-      mantissa = (0x800000 | mantissa) >> (-127 - exp + 1);
-      exp = -127;
-    }
-
-    // Construct the 32-bit representation
-    long bits = negative ? POWER_31_INT : 0x0L;
-    bits |= (exp + 127) << 23;
-    bits |= mantissa;
-
-    return (int) bits;
+  // This method is kept private since it returns canonical NaN in Firefox.
+  private static int floatToRawIntBits(float value) {
+    return JsUtils.floatToRawIntBits(value);
   }
 
   /**
@@ -94,40 +62,7 @@
   }
 
   public static float intBitsToFloat(int bits) {
-    boolean negative = (bits & 0x80000000) != 0;
-    int exp = (bits >> 23) & 0xff;
-    bits &= 0x7fffff;
-
-    if (exp == 0x0) {
-      // Handle +/- 0 here, denorms below
-      if (bits == 0) {
-        return negative ? -0.0f : 0.0f;
-      }
-    } else if (exp == 0xff) {
-      // Inf & NaN
-      if (bits == 0) {
-        return negative ? NEGATIVE_INFINITY : POSITIVE_INFINITY;
-      } else {
-        return NaN;
-      }
-    }
-
-    if (exp == 0) {
-      // Input is denormalized, renormalize by shifting left until there is a
-      // leading 1
-      exp = 1;
-      while ((bits & 0x800000) == 0) {
-        bits <<= 1;
-        exp--;
-      }
-      bits &= 0x7fffff;
-    }
-
-    // Build the bits of a 64-bit double from the incoming bits
-    long bits64 = negative ? 0x8000000000000000L : 0x0L;
-    bits64 |= ((long) (exp + 896)) << 52;
-    bits64 |= ((long) bits) << 29;
-    return (float) Double.longBitsToDouble(bits64);
+    return JsUtils.intBitsToFloat(bits);
   }
 
   public static boolean isFinite(float x) {
diff --git a/user/super/com/google/gwt/emul/javaemul/internal/JsUtils.java b/user/super/com/google/gwt/emul/javaemul/internal/JsUtils.java
index c8bf1e8..21bf263 100644
--- a/user/super/com/google/gwt/emul/javaemul/internal/JsUtils.java
+++ b/user/super/com/google/gwt/emul/javaemul/internal/JsUtils.java
@@ -87,5 +87,56 @@
   public static native <T> T getProperty(Object map, String key) /*-{
     return map[key];
   }-*/;
+
+  @JsType(isNative = true, namespace = "<window>")
+  static class ArrayBuffer {
+    ArrayBuffer(int size) {}
+  }
+
+  @JsType(isNative = true, namespace = "<window>")
+  static class Float64Array {
+    Float64Array(ArrayBuffer buf) {}
+  }
+
+  @JsType(isNative = true, namespace = "<window>")
+  static class Float32Array {
+    Float32Array(ArrayBuffer buf) {}
+  }
+
+  @JsType(isNative = true, namespace = "<window>")
+  static class Uint32Array {
+    Uint32Array(ArrayBuffer buf) {}
+  }
+
+  public static int floatToRawIntBits(float value) {
+    ArrayBuffer buf = new ArrayBuffer(4);
+    JsUtils.<float[]>uncheckedCast(new Float32Array(buf))[0] = value;
+    return JsUtils.<int[]>uncheckedCast(new Uint32Array(buf))[0] | 0;
+  }
+
+  public static float intBitsToFloat(int value) {
+    ArrayBuffer buf = new ArrayBuffer(4);
+    JsUtils.<int[]>uncheckedCast(new Uint32Array(buf))[0] = value;
+    return JsUtils.<float[]>uncheckedCast(new Float32Array(buf))[0];
+  }
+
+  public static long doubleToRawLongBits(double value) {
+    ArrayBuffer buf = new ArrayBuffer(8);
+    JsUtils.<double[]>uncheckedCast(new Float64Array(buf))[0] = value;
+    int[] intBits = JsUtils.<int[]>uncheckedCast(new Uint32Array(buf));
+    long highBits = ((long) (intBits[1] | 0)) << 32;
+    long lowBits = (intBits[0] | 0) & 0x00000000ffffffffL;
+    return highBits | lowBits;
+  }
+
+  public static double longBitsToDouble(long value) {
+    ArrayBuffer buf = new ArrayBuffer(8);
+    int[] intBits = JsUtils.<int[]>uncheckedCast(new Uint32Array(buf));
+    intBits[0] = (int) value;
+    intBits[1] = (int) (value >>> 32);
+    return JsUtils.<double[]>uncheckedCast(new Float64Array(buf))[0];
+  }
+
+  private JsUtils() {}
 }
 
diff --git a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
index 8567199..befde65 100644
--- a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
@@ -539,5 +539,12 @@
     // Do we need a special check for +inf == +inf and -inf == -inf?
     assertEquals(expected, actual);
   }
-}
 
+  // Disabled since it is broken for Firefox.
+  // public void testDoubleToRawLongBits() {
+  //   long l = 0x7ff80000000004d2L;
+  //   double d = Double.longBitsToDouble(l);
+  //   assertEquals(l, Double.doubleToRawLongBits(d));
+  //   assertEquals(0x7ff8000000000000L, Double.doubleToLongBits(d));
+  // }
+}
diff --git a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
index 395bcd1..be7284c 100644
--- a/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/FloatTest.java
@@ -426,4 +426,12 @@
     }
     assertEquals(expected, actual);
   }
+
+  // Disabled since it is broken for Firefox.
+  // public void testFloatToRawIntBits() {
+  //   int i = 0x7fc004d2;
+  //   float f = Float.intBitsToFloat(i);
+  //   assertEquals(i, Float.floatToRawIntBits(f));
+  //   assertEquals(0x7fc00000, Float.floatToIntBits(f));
+  // }
 }