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 ce65260..16fd322 100644
--- a/user/super/com/google/gwt/emul/java/lang/Double.java
+++ b/user/super/com/google/gwt/emul/java/lang/Double.java
@@ -22,7 +22,7 @@
   public static final double MAX_VALUE = 1.7976931348623157e+308;
   public static final double MIN_VALUE = 4.9e-324;
   public static final double MIN_NORMAL = 2.2250738585072014e-308;
-  public static final int MAX_EXPONENT = 1023; 
+  public static final int MAX_EXPONENT = 1023;
                              // ==Math.getExponent(Double.MAX_VALUE);
   public static final int MIN_EXPONENT = -1022; 
                              // ==Math.getExponent(Double.MIN_NORMAL);;
@@ -31,6 +31,26 @@
   public static final double NEGATIVE_INFINITY = -1d / 0d;
   public static final double POSITIVE_INFINITY = 1d / 0d;
   public static final int SIZE = 64;
+  static final int EXPONENT_BITSIZE = 11;
+  // the extra -1 is for the sign bit
+  static final int MANTISSA_BITSIZE = SIZE - EXPONENT_BITSIZE
+      - 1;
+  // the exponent is biased by one less than its midpoint, e.g. 2^11 / 2 - 1;
+  static final int EXPONENT_BIAS = 1 << (EXPONENT_BITSIZE - 1) - 1;
+  // the mask is all 1 bits in the exponent, e.g. 0x7ff shifted over by 52
+  static final long EXPONENT_MASK = (1L
+      << EXPONENT_BITSIZE - 1) << MANTISSA_BITSIZE;
+  // place 1-bit in top position
+  static final long NAN_MANTISSA = 1L << (MANTISSA_BITSIZE - 1);
+  // sign bit is the MSB bit
+  static final long SIGN_BIT = 0x1L << (SIZE - 1);
+  // Zero represented in biased form
+  static final int BIASED_ZERO_EXPONENT = EXPONENT_BIAS;
+  // The maximum mantissa value, represented as a double
+  static final double MAX_MANTISSA_VALUE = Math
+      .pow(2, MANTISSA_BITSIZE);
+  // The mantissa of size MANTISSA_BITSIZE with all bits set to 1_
+  static final long MANTISSA_MASK = (1L << MANTISSA_BITSIZE) - 1;
 
   public static int compare(double x, double y) {
     if (x < y) {
@@ -42,6 +62,83 @@
     }
   }
 
+  // Theory of operation: Let a double number d be represented as
+  // 1.M * 2^E, where the leading bit is assumed to be 1,
+  // the fractional mantissa M is multiplied 2 to the power of E.
+  // We want to reliably recover M and E, and then encode them according
+  // to IEEE754 (see http://en.wikipedia.org/wiki/IEEE754)
+  public static long doubleToLongBits(final double d) {
+
+    long sign = (d < 0 ? SIGN_BIT : 0);
+    long exponent = 0;
+    double absV = Math.abs(d);
+
+    if (Double.isNaN(d)) {
+      // IEEE754, NaN exponent bits all 1s, and mantissa is non-zero
+      return EXPONENT_MASK | NAN_MANTISSA;
+    }
+    if (Double.isInfinite(d)) {
+      // an infinite number is a number with a zero mantissa and all
+      // exponent bits set to 1
+      exponent = EXPONENT_MASK;
+      absV = 0.0;
+    } else {
+      if (absV == 0.0) {
+        // IEEE754, exponent is 0, mantissa is zero
+        // we don't handle negative zero at the moment, it is treated as
+        // positive zero
+        exponent = 0L;
+      } else {
+        // get an approximation to the exponent
+        // if d = 1.M * 2^E then
+        //   log2(d) = log(1.M) + log2(2^E) = log(1.M) + E
+        //   floor(log(1.M) + E) = E because log(1.M) always < 1
+        // it may turn out log2(x) = log(x)/log(2) always returns the
+        // the correct exponent, but this method is more defensive
+        // with respect to precision to avoid off by 1 problems
+        int guess = (int) Math.floor(Math.log(absV) / Math.log(2));
+        // force it to MAX_EXPONENT, MAX_EXPONENT interval
+        // (<= -MAX_EXPONENT = denorm/zero)
+        guess = Math.max(-MAX_EXPONENT, Math.min(guess, MAX_EXPONENT));
+
+        // Recall that d = 1.M * 2^E, so dividing by 2^E should leave
+        // us with 1.M
+        double exp = Math.pow(2, guess);
+        absV = absV / exp;
+
+        // while the number is still bigger than a normalized number
+        // increment exponent guess
+        // This might occur if there is some precision loss in determining
+        // the exponent
+        while (absV > 2.0) {
+          guess++;
+          absV /= 2.0;
+        }
+        // if the number is smaller than a normalized number
+        // decrement exponent. If the exponent becomes zero, and we
+        // fail to achieve a normalized mantissa, then this number
+        // must be a denormalized value
+        while (absV < 1 && guess > 0) {
+          guess--;
+          absV *= 2;
+        }
+        exponent = (guess + EXPONENT_BIAS) << MANTISSA_BITSIZE;
+      }
+    }
+    // if denormalized
+    if (exponent <= BIASED_ZERO_EXPONENT) {
+      // denormalized numbers have an exponent of zero, but pretend
+      // they have an exponent of 1, so since there is an implicit
+      // * 2^1 for denorms, we correct by dividing by 2
+      absV /= 2;
+    }
+    // the input value has now been stripped of its exponent
+    // and is in the range [1,2), we strip off the leading decimal to normalize
+    // and use the remainer as a percentage of the significand value (2^52)
+    long mantissa = (long) ((absV % 1) * MAX_MANTISSA_VALUE);
+    return sign | exponent | (mantissa & MANTISSA_MASK);
+  }
+
   /**
    * @skip Here for shared implementation with Arrays.hashCode
    */
@@ -57,6 +154,33 @@
     return isNaN(x);
   }-*/;
 
+  public static double longBitsToDouble(long value) {
+    // exponent in MSB bits 1-11
+    int exp = (int) ((value & EXPONENT_MASK) >> MANTISSA_BITSIZE);
+    // unbias exponent handle denorm case
+    int denorm = (exp == 0 ? 1 : 0);
+    // denorm exponent becomes -1022
+    exp = exp - EXPONENT_BIAS + denorm;
+    // mantissa in LSB 52 bits
+    long mantissa = (value & MANTISSA_MASK);
+    // sign in MSB bit 0
+    int sign = (value & SIGN_BIT) != 0 ? -1 : 1;
+    // unbiased exponent value of EXPONENT_BIAS + 1 (e.g. 1024)
+    // is equivalent to all 1 bits in biased exp (e.g. 2047)
+    if (exp == EXPONENT_BIAS + 1) {
+      if (mantissa != 0) {
+        return Double.NaN;
+      } else {
+        return sign < 0 ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
+      }
+    }
+    // non-denormized numbers get 1.0 added back, since our first digit is 
+    // always a 1
+    // mantissa is divided by 2^52, and multiplied by 2^exponent
+    return sign * ((mantissa / MAX_MANTISSA_VALUE + (1 - denorm)) * Math
+        .pow(2, exp));
+  }
+
   public static double parseDouble(String s) throws NumberFormatException {
     return __parseAndValidateDouble(s);
   }
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 283763b..728ce1c 100644
--- a/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
+++ b/user/test/com/google/gwt/emultest/java/lang/DoubleTest.java
@@ -23,6 +23,17 @@
  */
 public class DoubleTest extends GWTTestCase {
 
+  // Some actual results from JDK1.6 VM doubleToLongBits calls    
+  private static final long NAN_LONG_VALUE = 0x7ff8000000000000L;
+  private static final long POSINF_LONG_VALUE = 0x7ff0000000000000L;
+  private static final long NEGINF_LONG_VALUE = 0xfff0000000000000L;
+  private static final long MAXD_LONG_VALUE = 0x7fefffffffffffffL;
+  private static final long MIND_LONG_VALUE = 0x1L;
+  private static final long MINNORM_LONG_VALUE = 0x10000000000000L;
+  private static final double TEST1_DOUBLE_VALUE = 2.3e27;
+  private static final long TEST1_LONG_VALUE = 0x459dba0fc757e49cL;
+  private static final long NEGTEST1_LONG_VALUE = 0xc59dba0fc757e49cL;
+
   public String getModuleName() {
     return "com.google.gwt.emultest.EmulSuite";
   }
@@ -64,6 +75,31 @@
     // Double.MIN_EXPONENT);
   }
 
+  public void testDoubleToLongBits() {
+    assertEquals(Double.doubleToLongBits(Double.NaN), NAN_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.POSITIVE_INFINITY), POSINF_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.NEGATIVE_INFINITY), NEGINF_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MAX_VALUE), MAXD_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MIN_VALUE), MIND_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MIN_NORMAL), MINNORM_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MAX_VALUE), MAXD_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MIN_VALUE), MIND_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(Double.MIN_NORMAL), MINNORM_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(TEST1_DOUBLE_VALUE), TEST1_LONG_VALUE);
+    assertEquals(Double.doubleToLongBits(-TEST1_DOUBLE_VALUE), NEGTEST1_LONG_VALUE);
+  }
+  
+  public void testLongBitsToDouble() {
+    assertTrue(Double.isNaN(Double.longBitsToDouble(NAN_LONG_VALUE)));
+    assertTrue(Double.POSITIVE_INFINITY == Double.longBitsToDouble(POSINF_LONG_VALUE));
+    assertTrue(Double.NEGATIVE_INFINITY == Double.longBitsToDouble(NEGINF_LONG_VALUE));
+    assertTrue(Double.MAX_VALUE == Double.longBitsToDouble(MAXD_LONG_VALUE));
+    assertTrue(Double.MIN_VALUE == Double.longBitsToDouble(MIND_LONG_VALUE));
+    assertTrue(Double.MIN_NORMAL == Double.longBitsToDouble(MINNORM_LONG_VALUE));
+    assertTrue(TEST1_DOUBLE_VALUE == Double.longBitsToDouble(TEST1_LONG_VALUE));
+    assertTrue(-TEST1_DOUBLE_VALUE == Double.longBitsToDouble(NEGTEST1_LONG_VALUE));
+  }
+
   public void testParse() {
     assertTrue(0 == Double.parseDouble("0"));
     assertTrue(-1.5 == Double.parseDouble("-1.5"));