Backout 4fc2f49371a8 (bug 725550) for build failures
authorMarco Bonardo <mbonardo@mozilla.com>
Sat, 25 Feb 2012 00:16:47 +0100
changeset 87684 676cff5e3513d4e356a635c39add60cf69d514d2
parent 87683 791442d6d0123bff6551f05148a61ca6ba81b585
child 87685 d4105352a832b4a614daf469411895b24ea2bb16
push id22140
push usermak77@bonardo.net
push dateSat, 25 Feb 2012 10:12:06 +0000
treeherdermozilla-central@ce20e9b47e9c [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs725550
milestone13.0a1
backs out4fc2f49371a8cfbdbaea1948f02d4750e3e82296
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backout 4fc2f49371a8 (bug 725550) for build failures
content/canvas/src/CustomQS_Canvas2D.h
dom/base/nsDOMClassInfo.cpp
dom/indexedDB/IDBIndex.cpp
dom/indexedDB/IDBObjectStore.cpp
dom/indexedDB/Key.cpp
dom/plugins/base/nsJSNPRuntime.cpp
dom/sms/src/SmsMessage.cpp
dom/workers/Events.cpp
dom/workers/Events.h
dom/workers/File.cpp
dom/workers/WorkerPrivate.cpp
js/jsd/jsd.h
js/jsd/jsdebug.h
js/src/builtin/MapObject.cpp
js/src/builtin/RegExp.cpp
js/src/ctypes/CTypes.cpp
js/src/frontend/BytecodeEmitter.cpp
js/src/frontend/FoldConstants.cpp
js/src/frontend/ParseNode.h
js/src/frontend/TokenStream.cpp
js/src/frontend/TokenStream.h
js/src/jsapi-tests/testParseJSON.cpp
js/src/jsapi.cpp
js/src/jsapi.h
js/src/jsarray.cpp
js/src/jsarray.h
js/src/jsbool.cpp
js/src/jsclone.cpp
js/src/jsclone.h
js/src/jsdate.cpp
js/src/jsdate.h
js/src/jsinterp.cpp
js/src/jsmath.cpp
js/src/jsmath.h
js/src/jsnum.cpp
js/src/jsnum.h
js/src/jsnuminlines.h
js/src/json.cpp
js/src/jsonparser.cpp
js/src/jsonparser.h
js/src/jsopcode.cpp
js/src/jspubtd.h
js/src/jsscript.cpp
js/src/jsstr.cpp
js/src/jstypedarray.cpp
js/src/jsxdrapi.cpp
js/src/jsxdrapi.h
js/src/jsxml.cpp
js/src/methodjit/TypedArrayIC.h
js/src/perf/jsperf.cpp
js/src/shell/js.cpp
js/src/vm/Debugger.cpp
js/src/vm/NumberObject-inl.h
js/src/vm/NumberObject.h
js/xpconnect/src/XPCComponents.cpp
js/xpconnect/src/XPCConvert.cpp
js/xpconnect/src/XPCQuickStubs.h
js/xpconnect/src/codegen.py
js/xpconnect/src/dombindings.cpp
js/xpconnect/src/qsgen.py
toolkit/components/places/Helpers.cpp
toolkit/components/places/History.cpp
--- a/content/canvas/src/CustomQS_Canvas2D.h
+++ b/content/canvas/src/CustomQS_Canvas2D.h
@@ -267,17 +267,17 @@ nsIDOMCanvasRenderingContext2D_CreateIma
 
         uint32_t data_width, data_height;
         if (!GetImageDataDimensions(cx, dataObject, &data_width, &data_height))
             return false;
 
         return CreateImageData(cx, data_width, data_height, NULL, 0, 0, vp);
     }
 
-    double width, height;
+    jsdouble width, height;
     if (!JS_ValueToNumber(cx, argv[0], &width) ||
         !JS_ValueToNumber(cx, argv[1], &height))
         return false;
 
     if (!NS_finite(width) || !NS_finite(height))
         return xpc_qsThrow(cx, NS_ERROR_DOM_NOT_SUPPORTED_ERR);
 
     if (!width || !height)
@@ -306,17 +306,17 @@ nsIDOMCanvasRenderingContext2D_GetImageD
     if (!xpc_qsUnwrapThis(cx, obj, &self, &selfref.ptr, tvr.jsval_addr(), nsnull))
         return JS_FALSE;
 
     if (argc < 4)
         return xpc_qsThrow(cx, NS_ERROR_XPC_NOT_ENOUGH_ARGS);
 
     jsval *argv = JS_ARGV(cx, vp);
 
-    double xd, yd, width, height;
+    jsdouble xd, yd, width, height;
     if (!JS_ValueToNumber(cx, argv[0], &xd) ||
         !JS_ValueToNumber(cx, argv[1], &yd) ||
         !JS_ValueToNumber(cx, argv[2], &width) ||
         !JS_ValueToNumber(cx, argv[3], &height))
         return false;
 
     if (!NS_finite(xd) || !NS_finite(yd) ||
         !NS_finite(width) || !NS_finite(height))
--- a/dom/base/nsDOMClassInfo.cpp
+++ b/dom/base/nsDOMClassInfo.cpp
@@ -4467,17 +4467,17 @@ nsDOMClassInfo::GetArrayIndexFromId(JSCo
 
   jsint i;
   if (JSID_IS_INT(id)) {
       i = JSID_TO_INT(id);
   } else {
       JSAutoRequest ar(cx);
 
       jsval idval;
-      double array_index;
+      jsdouble array_index;
       if (!::JS_IdToValue(cx, id, &idval) ||
           !::JS_ValueToNumber(cx, idval, &array_index) ||
           !::JS_DoubleIsInt32(array_index, &i)) {
         return -1;
       }
   }
 
   if (aIsNumber) {
--- a/dom/indexedDB/IDBIndex.cpp
+++ b/dom/indexedDB/IDBIndex.cpp
@@ -1445,10 +1445,10 @@ CountHelper::DoDatabaseWork(mozIStorageC
   mCount = stmt->AsInt64(0);
   return NS_OK;
 }
 
 nsresult
 CountHelper::GetSuccessResult(JSContext* aCx,
                               jsval* aVal)
 {
-  return JS_NewNumberValue(aCx, static_cast<double>(mCount), aVal);
+  return JS_NewNumberValue(aCx, static_cast<jsdouble>(mCount), aVal);
 }
--- a/dom/indexedDB/IDBObjectStore.cpp
+++ b/dom/indexedDB/IDBObjectStore.cpp
@@ -895,30 +895,30 @@ SwapBytes(PRUint32 u)
          ((u & 0x0000ff00U) << 8) |                                           
          ((u & 0x00ff0000U) >> 8) |                                           
          ((u & 0xff000000U) >> 24);
 #else
   return u;
 #endif
 }
 
-static inline double
+static inline jsdouble
 SwapBytes(PRUint64 u)
 {
 #ifdef IS_BIG_ENDIAN
   return ((u & 0x00000000000000ffLLU) << 56) |
          ((u & 0x000000000000ff00LLU) << 40) |
          ((u & 0x0000000000ff0000LLU) << 24) |
          ((u & 0x00000000ff000000LLU) << 8) |
          ((u & 0x000000ff00000000LLU) >> 8) |
          ((u & 0x0000ff0000000000LLU) >> 24) |
          ((u & 0x00ff000000000000LLU) >> 40) |
          ((u & 0xff00000000000000LLU) >> 56);
 #else
-  return double(u);
+  return jsdouble(u);
 #endif
 }
 
 static inline bool
 StructuredCloneReadString(JSStructuredCloneReader* aReader,
                           nsCString& aString)
 {
   PRUint32 length;
@@ -2014,17 +2014,17 @@ AddHelper::DoDatabaseWork(mozIStorageCon
 
     if (keyUnset && !keyPath.IsEmpty()) {
       // Special case where someone put an object into an autoIncrement'ing
       // objectStore with no key in its keyPath set. We needed to figure out
       // which row id we would get above before we could set that properly.
 
       // This is a duplicate of the js engine's byte munging here
       union {
-        double d;
+        jsdouble d;
         PRUint64 u;
       } pun;
     
       pun.d = SwapBytes(static_cast<PRUint64>(autoIncrementNum));
 
       JSAutoStructuredCloneBuffer& buffer = mCloneWriteInfo.mCloneBuffer;
       PRUint64 offsetToKeyProp = mCloneWriteInfo.mOffsetToKeyProp;
 
@@ -2846,10 +2846,10 @@ CountHelper::DoDatabaseWork(mozIStorageC
   mCount = stmt->AsInt64(0);
   return NS_OK;
 }
 
 nsresult
 CountHelper::GetSuccessResult(JSContext* aCx,
                               jsval* aVal)
 {
-  return JS_NewNumberValue(aCx, static_cast<double>(mCount), aVal);
+  return JS_NewNumberValue(aCx, static_cast<jsdouble>(mCount), aVal);
 }
--- a/dom/indexedDB/Key.cpp
+++ b/dom/indexedDB/Key.cpp
@@ -243,17 +243,17 @@ Key::DecodeJSVal(const unsigned char*& a
   else if (*aPos - aTypeOffset == eString) {
     nsString key;
     DecodeString(aPos, aEnd, key);
     if (!xpc::StringToJsval(aCx, key, aVal)) {
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
   }
   else if (*aPos - aTypeOffset == eDate) {
-    double msec = static_cast<double>(DecodeNumber(aPos, aEnd));
+    jsdouble msec = static_cast<jsdouble>(DecodeNumber(aPos, aEnd));
     JSObject* date = JS_NewDateObjectMsec(aCx, msec);
     if (!date) {
       NS_WARNING("Failed to make date!");
       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
     }
 
     *aVal = OBJECT_TO_JSVAL(date);
   }
--- a/dom/plugins/base/nsJSNPRuntime.cpp
+++ b/dom/plugins/base/nsJSNPRuntime.cpp
@@ -452,17 +452,17 @@ JSValToNPVariant(NPP npp, JSContext *cx,
       VOID_TO_NPVARIANT(*variant);
     } else if (JSVAL_IS_NULL(val)) {
       NULL_TO_NPVARIANT(*variant);
     } else if (JSVAL_IS_BOOLEAN(val)) {
       BOOLEAN_TO_NPVARIANT(JSVAL_TO_BOOLEAN(val), *variant);
     } else if (JSVAL_IS_INT(val)) {
       INT32_TO_NPVARIANT(JSVAL_TO_INT(val), *variant);
     } else if (JSVAL_IS_DOUBLE(val)) {
-      double d = JSVAL_TO_DOUBLE(val);
+      jsdouble d = JSVAL_TO_DOUBLE(val);
       jsint i;
       if (JS_DoubleIsInt32(d, &i)) {
         INT32_TO_NPVARIANT(i, *variant);
       } else {
         DOUBLE_TO_NPVARIANT(d, *variant);
       }
     } else if (JSVAL_IS_STRING(val)) {
       JSString *jsstr = JSVAL_TO_STRING(val);
--- a/dom/sms/src/SmsMessage.cpp
+++ b/dom/sms/src/SmsMessage.cpp
@@ -103,17 +103,17 @@ SmsMessage::Create(PRInt32 aId,
     if (!JS_ObjectIsDate(aCx, &obj)) {
       return NS_ERROR_INVALID_ARG;
     }
     data.timestamp() = js_DateGetMsecSinceEpoch(aCx, &obj);
   } else {
     if (!aTimestamp.isNumber()) {
       return NS_ERROR_INVALID_ARG;
     }
-    double number = aTimestamp.toNumber();
+    jsdouble number = aTimestamp.toNumber();
     if (static_cast<PRUint64>(number) != number) {
       return NS_ERROR_INVALID_ARG;
     }
     data.timestamp() = static_cast<PRUint64>(number);
   }
 
   nsCOMPtr<nsIDOMMozSmsMessage> message = new SmsMessage(data);
   message.swap(*aMessage);
--- a/dom/workers/Events.cpp
+++ b/dom/workers/Events.cpp
@@ -845,17 +845,17 @@ public:
   InitClass(JSContext* aCx, JSObject* aObj, JSObject* aParentProto)
   {
     return JS_InitClass(aCx, aObj, aParentProto, &sClass, Construct, 0,
                         sProperties, sFunctions, NULL, NULL);
   }
 
   static JSObject*
   Create(JSContext* aCx, JSObject* aParent, JSString* aType,
-         bool aLengthComputable, double aLoaded, double aTotal)
+         bool aLengthComputable, jsdouble aLoaded, jsdouble aTotal)
   {
     JSString* type = JS_InternJSString(aCx, aType);
     if (!type) {
       return NULL;
     }
 
     JSObject* obj = JS_NewObject(aCx, &sClass, NULL, aParent);
     if (!obj) {
@@ -902,18 +902,18 @@ private:
                          JSMSG_INCOMPATIBLE_PROTO, sClass.name, aFunctionName,
                          classPtr->name);
     return NULL;
   }
 
   static void
   InitProgressEventCommon(JSObject* aObj, Event* aEvent, JSString* aType,
                           JSBool aBubbles, JSBool aCancelable,
-                          JSBool aLengthComputable, double aLoaded,
-                          double aTotal, bool aIsTrusted)
+                          JSBool aLengthComputable, jsdouble aLoaded,
+                          jsdouble aTotal, bool aIsTrusted)
   {
     Event::InitEventCommon(aObj, aEvent, aType, aBubbles, aCancelable,
                            aIsTrusted);
     JS_SetReservedSlot(aObj, SLOT_lengthComputable,
                        aLengthComputable ? JSVAL_TRUE : JSVAL_FALSE);
     JS_SetReservedSlot(aObj, SLOT_loaded, DOUBLE_TO_JSVAL(aLoaded));
     JS_SetReservedSlot(aObj, SLOT_total, DOUBLE_TO_JSVAL(aTotal));
   }
@@ -962,17 +962,17 @@ private:
 
     ProgressEvent* event = GetInstancePrivate(aCx, obj, sFunctions[0].name);
     if (!event) {
       return false;
     }
 
     JSString* type;
     JSBool bubbles, cancelable, lengthComputable;
-    double loaded, total;
+    jsdouble loaded, total;
     if (!JS_ConvertArguments(aCx, aArgc, JS_ARGV(aCx, aVp), "Sbbbdd", &type,
                              &bubbles, &cancelable, &lengthComputable, &loaded,
                              &total)) {
       return false;
     }
 
     InitProgressEventCommon(obj, event, type, bubbles, cancelable,
                             lengthComputable, loaded, total, false);
@@ -1060,17 +1060,17 @@ CreateErrorEvent(JSContext* aCx, JSStrin
 {
   JSObject* global = JS_GetGlobalForScopeChain(aCx);
   return ErrorEvent::Create(aCx, global, aMessage, aFilename, aLineNumber,
                             aMainRuntime);
 }
 
 JSObject*
 CreateProgressEvent(JSContext* aCx, JSString* aType, bool aLengthComputable,
-                    double aLoaded, double aTotal)
+                    jsdouble aLoaded, jsdouble aTotal)
 {
   JSObject* global = JS_GetGlobalForScopeChain(aCx);
   return ProgressEvent::Create(aCx, global, aType, aLengthComputable, aLoaded,
                                aTotal);
 }
 
 bool
 IsSupportedEventClass(JSObject* aEvent)
--- a/dom/workers/Events.h
+++ b/dom/workers/Events.h
@@ -64,17 +64,17 @@ CreateMessageEvent(JSContext* aCx, JSAut
                    bool aMainRuntime);
 
 JSObject*
 CreateErrorEvent(JSContext* aCx, JSString* aMessage, JSString* aFilename,
                  uint32 aLineNumber, bool aMainRuntime);
 
 JSObject*
 CreateProgressEvent(JSContext* aCx, JSString* aType, bool aLengthComputable,
-                    double aLoaded, double aTotal);
+                    jsdouble aLoaded, jsdouble aTotal);
 
 bool
 IsSupportedEventClass(JSObject* aEvent);
 
 void
 SetEventTarget(JSObject* aEvent, JSObject* aTarget);
 
 bool
--- a/dom/workers/File.cpp
+++ b/dom/workers/File.cpp
@@ -135,17 +135,17 @@ private:
       return false;
     }
 
     PRUint64 size;
     if (NS_FAILED(blob->GetSize(&size))) {
       ThrowFileExceptionForCode(aCx, FILE_NOT_READABLE_ERR);
     }
 
-    if (!JS_NewNumberValue(aCx, double(size), aVp)) {
+    if (!JS_NewNumberValue(aCx, jsdouble(size), aVp)) {
       return false;
     }
 
     return true;
   }
 
   static JSBool
   GetType(JSContext* aCx, JSObject* aObj, jsid aIdval, jsval* aVp)
@@ -178,17 +178,17 @@ private:
       return false;
     }
 
     nsIDOMBlob* blob = GetInstancePrivate(aCx, obj, "slice");
     if (!blob) {
       return false;
     }
 
-    double start = 0, end = 0;
+    jsdouble start = 0, end = 0;
     JSString* jsContentType = JS_GetEmptyString(JS_GetRuntime(aCx));
     if (!JS_ConvertArguments(aCx, aArgc, JS_ARGV(aCx, aVp), "/IIS", &start,
                              &end, &jsContentType)) {
       return false;
     }
 
     nsDependentJSString contentType;
     if (!contentType.init(aCx, jsContentType)) {
--- a/dom/workers/WorkerPrivate.cpp
+++ b/dom/workers/WorkerPrivate.cpp
@@ -3528,17 +3528,17 @@ WorkerPrivate::SetTimeout(JSContext* aCx
   else {
     JS_ReportError(aCx, "Useless %s call (missing quotes around argument?)",
                    aIsInterval ? "setInterval" : "setTimeout");
     return false;
   }
 
   // See if any of the optional arguments were passed.
   if (aArgc > 1) {
-    double intervalMS = 0;
+    jsdouble intervalMS = 0;
     if (!JS_ValueToNumber(aCx, argv[1], &intervalMS)) {
       return false;
     }
     newInfo->mInterval = TimeDuration::FromMilliseconds(intervalMS);
 
     if (aArgc > 2 && JSVAL_IS_OBJECT(newInfo->mTimeoutVal)) {
       nsTArray<jsval> extraArgVals(aArgc - 2);
       for (uintN index = 2; index < aArgc; index++) {
--- a/js/jsd/jsd.h
+++ b/js/jsd/jsd.h
@@ -205,22 +205,22 @@ struct JSDScript
 struct JSDProfileData
 {
     JSDProfileData* caller;
     int64_t  lastCallStart;
     int64_t  runningTime;
     uintN    callCount;
     uintN    recurseDepth;
     uintN    maxRecurseDepth;
-    double minExecutionTime;
-    double maxExecutionTime;
-    double totalExecutionTime;
-    double minOwnExecutionTime;
-    double maxOwnExecutionTime;
-    double totalOwnExecutionTime;
+    jsdouble minExecutionTime;
+    jsdouble maxExecutionTime;
+    jsdouble totalExecutionTime;
+    jsdouble minOwnExecutionTime;
+    jsdouble maxOwnExecutionTime;
+    jsdouble totalOwnExecutionTime;
 };
 
 struct JSDSourceText
 {
     JSCList          links;      /* we are part of a JSCList */
     char*            url;
     char*            text;
     uintN            textLength;
@@ -412,32 +412,32 @@ extern void
 jsd_SetScriptFlags(JSDContext *jsdc, JSDScript *script, uint32_t flags);
 
 extern uintN
 jsd_GetScriptCallCount(JSDContext* jsdc, JSDScript *script);
 
 extern  uintN
 jsd_GetScriptMaxRecurseDepth(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptMinExecutionTime(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptMaxExecutionTime(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptTotalExecutionTime(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptMinOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptMaxOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
-extern double
+extern jsdouble
 jsd_GetScriptTotalOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 extern void
 jsd_ClearScriptProfileData(JSDContext* jsdc, JSDScript *script);
 
 extern JSScript *
 jsd_GetJSScript (JSDContext *jsdc, JSDScript *script);
 
@@ -967,17 +967,17 @@ jsd_IsValueNative(JSDContext* jsdc, JSDV
 /**************************************************/
 
 extern JSBool
 jsd_GetValueBoolean(JSDContext* jsdc, JSDValue* jsdval);
 
 extern int32_t
 jsd_GetValueInt(JSDContext* jsdc, JSDValue* jsdval);
 
-extern double
+extern jsdouble
 jsd_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval);
 
 extern JSString*
 jsd_GetValueString(JSDContext* jsdc, JSDValue* jsdval);
 
 extern JSString*
 jsd_GetValueFunctionId(JSDContext* jsdc, JSDValue* jsdval);
 
--- a/js/jsd/jsdebug.h
+++ b/js/jsd/jsdebug.h
@@ -328,50 +328,50 @@ JSD_GetScriptCallCount(JSDContext* jsdc,
 * Get the max number of times this script called itself, directly or indirectly.
 */
 extern JSD_PUBLIC_API(uintN)
 JSD_GetScriptMaxRecurseDepth(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the shortest execution time recorded.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptMinExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the longest execution time recorded.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptMaxExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the total amount of time spent in this script.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptTotalExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the shortest execution time recorded, excluding time spent in called
 * functions.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptMinOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the longest execution time recorded, excluding time spent in called
 * functions.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptMaxOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Get the total amount of time spent in this script, excluding time spent
 * in called functions.
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetScriptTotalOwnExecutionTime(JSDContext* jsdc, JSDScript *script);
 
 /*
 * Clear profile data for this script.
 */
 extern JSD_PUBLIC_API(void)
 JSD_ClearScriptProfileData(JSDContext* jsdc, JSDScript *script);
 
@@ -1288,17 +1288,17 @@ JSD_GetValueBoolean(JSDContext* jsdc, JS
 */
 extern JSD_PUBLIC_API(int32_t)
 JSD_GetValueInt(JSDContext* jsdc, JSDValue* jsdval);
 
 /*
 * Return double value (does NOT do conversion).
 * *** new for version 1.1 ****
 */
-extern JSD_PUBLIC_API(double)
+extern JSD_PUBLIC_API(jsdouble)
 JSD_GetValueDouble(JSDContext* jsdc, JSDValue* jsdval);
 
 /*
 * Return JSString value (DOES do conversion if necessary).
 * NOTE that the JSString returned is not protected from garbage
 * collection. It should be immediately read or wrapped using
 * JSD_NewValue(jsdc,STRING_TO_JSVAL(str)) if necessary.
 * *** new for version 1.1 ****
--- a/js/src/builtin/MapObject.cpp
+++ b/js/src/builtin/MapObject.cpp
@@ -81,17 +81,17 @@ HashableValue::setValue(JSContext *cx, c
 {
     if (v.isString() && v.toString()->isRope()) {
         /* Flatten this rope so that equals() is infallible. */
         JSString *str = v.toString()->ensureLinear(cx);
         if (!str)
             return false;
         value = StringValue(str);
     } else if (v.isDouble()) {
-        double d = v.toDouble();
+        jsdouble d = v.toDouble();
         int32_t i;
         if (JSDOUBLE_IS_INT32(d, &i)) {
             /* Normalize int32-valued doubles to int32 for faster hashing and testing. */
             value = Int32Value(i);
         } else if (JSDOUBLE_IS_NaN(d)) {
             /* NaNs with different bits must hash and test identically. */
             value = DoubleValue(js_NaN);
         } else {
--- a/js/src/builtin/RegExp.cpp
+++ b/js/src/builtin/RegExp.cpp
@@ -597,17 +597,17 @@ ExecuteRegExp(JSContext *cx, Native nati
         return false;
     const jschar *chars = linearInput->chars();
     size_t length = input->length();
 
     /* Step 4. */
     const Value &lastIndex = reobj.getLastIndex();
 
     /* Step 5. */
-    double i;
+    jsdouble i;
     if (!ToInteger(cx, lastIndex, &i))
         return false;
 
     /* Steps 6-7 (with sticky extension). */
     if (!re->global() && !re->sticky())
         i = 0;
 
     /* Step 9a. */
--- a/js/src/ctypes/CTypes.cpp
+++ b/js/src/ctypes/CTypes.cpp
@@ -452,17 +452,17 @@ static JSFunctionSpec sUInt64Functions[]
 static JSFunctionSpec sModuleFunctions[] = {
   JS_FN("open", Library::Open, 1, CTYPESFN_FLAGS),
   JS_FN("cast", CData::Cast, 2, CTYPESFN_FLAGS),
   JS_FN("getRuntime", CData::GetRuntime, 1, CTYPESFN_FLAGS),
   JS_FN("libraryName", Library::Name, 1, CTYPESFN_FLAGS),
   JS_FS_END
 };
 
-static inline bool FloatIsFinite(double f) {
+static inline bool FloatIsFinite(jsdouble f) {
 #ifdef WIN32
   return _finite(f) != 0;
 #else
   return finite(f);
 #endif
 }
 
 JS_ALWAYS_INLINE JSString*
@@ -999,42 +999,42 @@ struct ConvertImpl {
     return TargetType(d);
   }
 };
 
 #ifdef _MSC_VER
 // MSVC can't perform double to unsigned __int64 conversion when the
 // double is greater than 2^63 - 1. Help it along a little.
 template<>
-struct ConvertImpl<uint64_t, double> {
-  static JS_ALWAYS_INLINE uint64_t Convert(double d) {
+struct ConvertImpl<uint64_t, jsdouble> {
+  static JS_ALWAYS_INLINE uint64_t Convert(jsdouble d) {
     return d > 0x7fffffffffffffffui64 ?
            uint64_t(d - 0x8000000000000000ui64) + 0x8000000000000000ui64 :
            uint64_t(d);
   }
 };
 #endif
 
 // C++ doesn't guarantee that exact values are the only ones that will
 // round-trip. In fact, on some platforms, including SPARC, there are pairs of
 // values, a uint64_t and a double, such that neither value is exactly
 // representable in the other type, but they cast to each other.
 #ifdef SPARC
 // Simulate x86 overflow behavior
 template<>
-struct ConvertImpl<uint64_t, double> {
-  static JS_ALWAYS_INLINE uint64_t Convert(double d) {
+struct ConvertImpl<uint64_t, jsdouble> {
+  static JS_ALWAYS_INLINE uint64_t Convert(jsdouble d) {
     return d >= 0xffffffffffffffff ?
            0x8000000000000000 : uint64_t(d);
   }
 };
 
 template<>
-struct ConvertImpl<int64_t, double> {
-  static JS_ALWAYS_INLINE int64_t Convert(double d) {
+struct ConvertImpl<int64_t, jsdouble> {
+  static JS_ALWAYS_INLINE int64_t Convert(jsdouble d) {
     return d >= 0x7fffffffffffffff ?
            0x8000000000000000 : int64_t(d);
   }
 };
 #endif
 
 template<class TargetType, class FromType>
 static JS_ALWAYS_INLINE TargetType Convert(FromType d)
@@ -1136,41 +1136,41 @@ struct IsNegativeImpl<Type, true> {
 
 // Determine whether Type 'i' is negative.
 template<class Type>
 static JS_ALWAYS_INLINE bool IsNegative(Type i)
 {
   return IsNegativeImpl<Type, numeric_limits<Type>::is_signed>::Test(i);
 }
 
-// Implicitly convert val to bool, allowing JSBool, jsint, and double
+// Implicitly convert val to bool, allowing JSBool, jsint, and jsdouble
 // arguments numerically equal to 0 or 1.
 static bool
 jsvalToBool(JSContext* cx, jsval val, bool* result)
 {
   if (JSVAL_IS_BOOLEAN(val)) {
     *result = JSVAL_TO_BOOLEAN(val) != JS_FALSE;
     return true;
   }
   if (JSVAL_IS_INT(val)) {
     jsint i = JSVAL_TO_INT(val);
     *result = i != 0;
     return i == 0 || i == 1;
   }
   if (JSVAL_IS_DOUBLE(val)) {
-    double d = JSVAL_TO_DOUBLE(val);
+    jsdouble d = JSVAL_TO_DOUBLE(val);
     *result = d != 0;
     // Allow -0.
     return d == 1 || d == 0;
   }
   // Don't silently convert null to bool. It's probably a mistake.
   return false;
 }
 
-// Implicitly convert val to IntegerType, allowing JSBool, jsint, double,
+// Implicitly convert val to IntegerType, allowing JSBool, jsint, jsdouble,
 // Int64, UInt64, and CData integer types 't' where all values of 't' are
 // representable by IntegerType.
 template<class IntegerType>
 static bool
 jsvalToInteger(JSContext* cx, jsval val, IntegerType* result)
 {
   JS_STATIC_ASSERT(numeric_limits<IntegerType>::is_exact);
 
@@ -1178,17 +1178,17 @@ jsvalToInteger(JSContext* cx, jsval val,
     // Make sure the integer fits in the alotted precision, and has the right
     // sign.
     jsint i = JSVAL_TO_INT(val);
     return ConvertExact(i, result);
   }
   if (JSVAL_IS_DOUBLE(val)) {
     // Don't silently lose bits here -- check that val really is an
     // integer value, and has the right sign.
-    double d = JSVAL_TO_DOUBLE(val);
+    jsdouble d = JSVAL_TO_DOUBLE(val);
     return ConvertExact(d, result);
   }
   if (!JSVAL_IS_PRIMITIVE(val)) {
     JSObject* obj = JSVAL_TO_OBJECT(val);
     if (CData::IsCData(obj)) {
       JSObject* typeObj = CData::GetCType(obj);
       void* data = CData::GetData(obj);
 
@@ -1241,17 +1241,17 @@ jsvalToInteger(JSContext* cx, jsval val,
     *result = JSVAL_TO_BOOLEAN(val);
     JS_ASSERT(*result == 0 || *result == 1);
     return true;
   }
   // Don't silently convert null to an integer. It's probably a mistake.
   return false;
 }
 
-// Implicitly convert val to FloatType, allowing jsint, double,
+// Implicitly convert val to FloatType, allowing jsint, jsdouble,
 // Int64, UInt64, and CData numeric types 't' where all values of 't' are
 // representable by FloatType.
 template<class FloatType>
 static bool
 jsvalToFloat(JSContext *cx, jsval val, FloatType* result)
 {
   JS_STATIC_ASSERT(!numeric_limits<FloatType>::is_exact);
 
@@ -1354,17 +1354,17 @@ StringToInteger(JSContext* cx, JSString*
     if (i / base != ii) // overflow
       return false;
   }
 
   *result = i;
   return true;
 }
 
-// Implicitly convert val to IntegerType, allowing jsint, double,
+// Implicitly convert val to IntegerType, allowing jsint, jsdouble,
 // Int64, UInt64, and optionally a decimal or hexadecimal string argument.
 // (This is common code shared by jsvalToSize and the Int64/UInt64 constructors.)
 template<class IntegerType>
 static bool
 jsvalToBigInteger(JSContext* cx,
                   jsval val,
                   bool allowString,
                   IntegerType* result)
@@ -1375,17 +1375,17 @@ jsvalToBigInteger(JSContext* cx,
     // Make sure the integer fits in the alotted precision, and has the right
     // sign.
     jsint i = JSVAL_TO_INT(val);
     return ConvertExact(i, result);
   }
   if (JSVAL_IS_DOUBLE(val)) {
     // Don't silently lose bits here -- check that val really is an
     // integer value, and has the right sign.
-    double d = JSVAL_TO_DOUBLE(val);
+    jsdouble d = JSVAL_TO_DOUBLE(val);
     return ConvertExact(d, result);
   }
   if (allowString && JSVAL_IS_STRING(val)) {
     // Allow conversion from base-10 or base-16 strings, provided the result
     // fits in IntegerType. (This allows an Int64 or UInt64 object to be passed
     // to the JS array element operator, which will automatically call
     // toString() on the object for us.)
     return StringToInteger(cx, JSVAL_TO_STRING(val), result);
@@ -1405,28 +1405,28 @@ jsvalToBigInteger(JSContext* cx,
       int64_t i = Int64Base::GetInt(obj);
       return ConvertExact(i, result);
     }
   }
   return false;
 }
 
 // Implicitly convert val to a size value, where the size value is represented
-// by size_t but must also fit in a double.
+// by size_t but must also fit in a jsdouble.
 static bool
 jsvalToSize(JSContext* cx, jsval val, bool allowString, size_t* result)
 {
   if (!jsvalToBigInteger(cx, val, allowString, result))
     return false;
 
-  // Also check that the result fits in a double.
-  return Convert<size_t>(double(*result)) == *result;
-}
-
-// Implicitly convert val to IntegerType, allowing jsint, double,
+  // Also check that the result fits in a jsdouble.
+  return Convert<size_t>(jsdouble(*result)) == *result;
+}
+
+// Implicitly convert val to IntegerType, allowing jsint, jsdouble,
 // Int64, UInt64, and optionally a decimal or hexadecimal string argument.
 // (This is common code shared by jsvalToSize and the Int64/UInt64 constructors.)
 template<class IntegerType>
 static bool
 jsidToBigInteger(JSContext* cx,
                   jsid val,
                   bool allowString,
                   IntegerType* result)
@@ -1461,50 +1461,50 @@ jsidToBigInteger(JSContext* cx,
       int64_t i = Int64Base::GetInt(obj);
       return ConvertExact(i, result);
     }
   }
   return false;
 }
 
 // Implicitly convert val to a size value, where the size value is represented
-// by size_t but must also fit in a double.
+// by size_t but must also fit in a jsdouble.
 static bool
 jsidToSize(JSContext* cx, jsid val, bool allowString, size_t* result)
 {
   if (!jsidToBigInteger(cx, val, allowString, result))
     return false;
 
-  // Also check that the result fits in a double.
-  return Convert<size_t>(double(*result)) == *result;
+  // Also check that the result fits in a jsdouble.
+  return Convert<size_t>(jsdouble(*result)) == *result;
 }
 
 // Implicitly convert a size value to a jsval, ensuring that the size_t value
-// fits in a double.
+// fits in a jsdouble.
 static JSBool
 SizeTojsval(JSContext* cx, size_t size, jsval* result)
 {
-  if (Convert<size_t>(double(size)) != size) {
+  if (Convert<size_t>(jsdouble(size)) != size) {
     JS_ReportError(cx, "size overflow");
     return false;
   }
 
-  return JS_NewNumberValue(cx, double(size), result);
+  return JS_NewNumberValue(cx, jsdouble(size), result);
 }
 
 // Forcefully convert val to IntegerType when explicitly requested.
 template<class IntegerType>
 static bool
 jsvalToIntegerExplicit(jsval val, IntegerType* result)
 {
   JS_STATIC_ASSERT(numeric_limits<IntegerType>::is_exact);
 
   if (JSVAL_IS_DOUBLE(val)) {
     // Convert -Inf, Inf, and NaN to 0; otherwise, convert by C-style cast.
-    double d = JSVAL_TO_DOUBLE(val);
+    jsdouble d = JSVAL_TO_DOUBLE(val);
     *result = FloatIsFinite(d) ? IntegerType(d) : 0;
     return true;
   }
   if (!JSVAL_IS_PRIMITIVE(val)) {
     // Convert Int64 and UInt64 values by C-style cast.
     JSObject* obj = JSVAL_TO_OBJECT(val);
     if (Int64::IsInt64(obj)) {
       int64_t i = Int64Base::GetInt(obj);
@@ -1527,31 +1527,31 @@ jsvalToPtrExplicit(JSContext* cx, jsval 
   if (JSVAL_IS_INT(val)) {
     // jsint always fits in intptr_t. If the integer is negative, cast through
     // an intptr_t intermediate to sign-extend.
     jsint i = JSVAL_TO_INT(val);
     *result = i < 0 ? uintptr_t(intptr_t(i)) : uintptr_t(i);
     return true;
   }
   if (JSVAL_IS_DOUBLE(val)) {
-    double d = JSVAL_TO_DOUBLE(val);
+    jsdouble d = JSVAL_TO_DOUBLE(val);
     if (d < 0) {
       // Cast through an intptr_t intermediate to sign-extend.
       intptr_t i = Convert<intptr_t>(d);
-      if (double(i) != d)
+      if (jsdouble(i) != d)
         return false;
 
       *result = uintptr_t(i);
       return true;
     }
 
     // Don't silently lose bits here -- check that val really is an
     // integer value, and has the right sign.
     *result = Convert<uintptr_t>(d);
-    return double(*result) == d;
+    return jsdouble(*result) == d;
   }
   if (!JSVAL_IS_PRIMITIVE(val)) {
     JSObject* obj = JSVAL_TO_OBJECT(val);
     if (Int64::IsInt64(obj)) {
       int64_t i = Int64Base::GetInt(obj);
       intptr_t p = intptr_t(i);
 
       // Make sure the integer fits in the alotted precision.
@@ -1646,17 +1646,17 @@ ConvertToJS(JSContext* cx,
   case TYPE_bool:
     *result = *static_cast<bool*>(data) ? JSVAL_TRUE : JSVAL_FALSE;
     break;
 #define DEFINE_INT_TYPE(name, type, ffiType)                                   \
   case TYPE_##name: {                                                          \
     type value = *static_cast<type*>(data);                                    \
     if (sizeof(type) < 4)                                                      \
       *result = INT_TO_JSVAL(jsint(value));                                    \
-    else if (!JS_NewNumberValue(cx, double(value), result))                    \
+    else if (!JS_NewNumberValue(cx, jsdouble(value), result))                  \
       return false;                                                            \
     break;                                                                     \
   }
 #define DEFINE_WRAPPED_INT_TYPE(name, type, ffiType)                           \
   case TYPE_##name: {                                                          \
     /* Return an Int64 or UInt64 object - do not convert to a JS number. */    \
     uint64_t value;                                                            \
     JSObject* proto;                                                           \
@@ -1675,17 +1675,17 @@ ConvertToJS(JSContext* cx,
     if (!obj)                                                                  \
       return false;                                                            \
     *result = OBJECT_TO_JSVAL(obj);                                            \
     break;                                                                     \
   }
 #define DEFINE_FLOAT_TYPE(name, type, ffiType)                                 \
   case TYPE_##name: {                                                          \
     type value = *static_cast<type*>(data);                                    \
-    if (!JS_NewNumberValue(cx, double(value), result))                         \
+    if (!JS_NewNumberValue(cx, jsdouble(value), result))                       \
       return false;                                                            \
     break;                                                                     \
   }
 #define DEFINE_CHAR_TYPE(name, type, ffiType)                                  \
   case TYPE_##name:                                                            \
     /* Convert to an integer. We have no idea what character encoding to */    \
     /* use, if any. */                                                         \
     *result = INT_TO_JSVAL(*static_cast<type*>(data));                         \
@@ -2924,17 +2924,17 @@ CType::TypesEqual(JSObject* t1, JSObject
 
 bool
 CType::GetSafeSize(JSObject* obj, size_t* result)
 {
   JS_ASSERT(CType::IsCType(obj));
 
   jsval size = JS_GetReservedSlot(obj, SLOT_SIZE);
 
-  // The "size" property can be a jsint, a double, or JSVAL_VOID
+  // The "size" property can be a jsint, a jsdouble, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   if (JSVAL_IS_INT(size)) {
     *result = JSVAL_TO_INT(size);
     return true;
   }
   if (JSVAL_IS_DOUBLE(size)) {
     *result = Convert<size_t>(JSVAL_TO_DOUBLE(size));
     return true;
@@ -2948,32 +2948,32 @@ size_t
 CType::GetSize(JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
 
   jsval size = JS_GetReservedSlot(obj, SLOT_SIZE);
 
   JS_ASSERT(!JSVAL_IS_VOID(size));
 
-  // The "size" property can be a jsint, a double, or JSVAL_VOID
+  // The "size" property can be a jsint, a jsdouble, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   // For callers who know it can never be JSVAL_VOID, return a size_t directly.
   if (JSVAL_IS_INT(size))
     return JSVAL_TO_INT(size);
   return Convert<size_t>(JSVAL_TO_DOUBLE(size));
 }
 
 bool
 CType::IsSizeDefined(JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
 
   jsval size = JS_GetReservedSlot(obj, SLOT_SIZE);
 
-  // The "size" property can be a jsint, a double, or JSVAL_VOID
+  // The "size" property can be a jsint, a jsdouble, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   JS_ASSERT(JSVAL_IS_INT(size) || JSVAL_IS_DOUBLE(size) || JSVAL_IS_VOID(size));
   return !JSVAL_IS_VOID(size);
 }
 
 size_t
 CType::GetAlignment(JSObject* obj)
 {
@@ -3594,17 +3594,17 @@ ArrayType::CreateInternal(JSContext* cx,
   if (!CType::GetSafeSize(baseType, &baseSize)) {
     JS_ReportError(cx, "base size must be defined");
     return NULL;
   }
 
   jsval sizeVal = JSVAL_VOID;
   jsval lengthVal = JSVAL_VOID;
   if (lengthDefined) {
-    // Check for overflow, and convert to a jsint or double as required.
+    // Check for overflow, and convert to a jsint or jsdouble as required.
     size_t size = length * baseSize;
     if (length > 0 && size / length != baseSize) {
       JS_ReportError(cx, "size overflow");
       return NULL;
     }
     if (!SizeTojsval(cx, size, &sizeVal) ||
         !SizeTojsval(cx, length, &lengthVal))
       return NULL;
@@ -3745,17 +3745,17 @@ ArrayType::GetBaseType(JSObject* obj)
 bool
 ArrayType::GetSafeLength(JSObject* obj, size_t* result)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_array);
 
   jsval length = JS_GetReservedSlot(obj, SLOT_LENGTH);
 
-  // The "length" property can be a jsint, a double, or JSVAL_VOID
+  // The "length" property can be a jsint, a jsdouble, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   if (JSVAL_IS_INT(length)) {
     *result = JSVAL_TO_INT(length);
     return true;
   }
   if (JSVAL_IS_DOUBLE(length)) {
     *result = Convert<size_t>(JSVAL_TO_DOUBLE(length));
     return true;
@@ -3770,17 +3770,17 @@ ArrayType::GetLength(JSObject* obj)
 {
   JS_ASSERT(CType::IsCType(obj));
   JS_ASSERT(CType::GetTypeCode(obj) == TYPE_array);
 
   jsval length = JS_GetReservedSlot(obj, SLOT_LENGTH);
 
   JS_ASSERT(!JSVAL_IS_VOID(length));
 
-  // The "length" property can be a jsint, a double, or JSVAL_VOID
+  // The "length" property can be a jsint, a jsdouble, or JSVAL_VOID
   // (for arrays of undefined length), and must always fit in a size_t.
   // For callers who know it can never be JSVAL_VOID, return a size_t directly.
   if (JSVAL_IS_INT(length))
     return JSVAL_TO_INT(length);
   return Convert<size_t>(JSVAL_TO_DOUBLE(length));
 }
 
 ffi_type*
@@ -6202,17 +6202,17 @@ Int64::Lo(JSContext* cx, uintN argc, jsv
   if (argc != 1 || JSVAL_IS_PRIMITIVE(argv[0]) ||
       !Int64::IsInt64(JSVAL_TO_OBJECT(argv[0]))) {
     JS_ReportError(cx, "lo takes one Int64 argument");
     return JS_FALSE;
   }
 
   JSObject* obj = JSVAL_TO_OBJECT(argv[0]);
   int64_t u = Int64Base::GetInt(obj);
-  double d = uint32_t(INT64_LO(u));
+  jsdouble d = uint32_t(INT64_LO(u));
 
   jsval result;
   if (!JS_NewNumberValue(cx, d, &result))
     return JS_FALSE;
 
   JS_SET_RVAL(cx, vp, result);
   return JS_TRUE;
 }
@@ -6224,17 +6224,17 @@ Int64::Hi(JSContext* cx, uintN argc, jsv
   if (argc != 1 || JSVAL_IS_PRIMITIVE(argv[0]) ||
       !Int64::IsInt64(JSVAL_TO_OBJECT(argv[0]))) {
     JS_ReportError(cx, "hi takes one Int64 argument");
     return JS_FALSE;
   }
 
   JSObject* obj = JSVAL_TO_OBJECT(argv[0]);
   int64_t u = Int64Base::GetInt(obj);
-  double d = int32_t(INT64_HI(u));
+  jsdouble d = int32_t(INT64_HI(u));
 
   jsval result;
   if (!JS_NewNumberValue(cx, d, &result))
     return JS_FALSE;
 
   JS_SET_RVAL(cx, vp, result);
   return JS_TRUE;
 }
@@ -6369,17 +6369,17 @@ UInt64::Lo(JSContext* cx, uintN argc, js
   if (argc != 1 || JSVAL_IS_PRIMITIVE(argv[0]) ||
       !UInt64::IsUInt64(JSVAL_TO_OBJECT(argv[0]))) {
     JS_ReportError(cx, "lo takes one UInt64 argument");
     return JS_FALSE;
   }
 
   JSObject* obj = JSVAL_TO_OBJECT(argv[0]);
   uint64_t u = Int64Base::GetInt(obj);
-  double d = uint32_t(INT64_LO(u));
+  jsdouble d = uint32_t(INT64_LO(u));
 
   jsval result;
   if (!JS_NewNumberValue(cx, d, &result))
     return JS_FALSE;
 
   JS_SET_RVAL(cx, vp, result);
   return JS_TRUE;
 }
@@ -6391,17 +6391,17 @@ UInt64::Hi(JSContext* cx, uintN argc, js
   if (argc != 1 || JSVAL_IS_PRIMITIVE(argv[0]) ||
       !UInt64::IsUInt64(JSVAL_TO_OBJECT(argv[0]))) {
     JS_ReportError(cx, "hi takes one UInt64 argument");
     return JS_FALSE;
   }
 
   JSObject* obj = JSVAL_TO_OBJECT(argv[0]);
   uint64_t u = Int64Base::GetInt(obj);
-  double d = uint32_t(INT64_HI(u));
+  jsdouble d = uint32_t(INT64_HI(u));
 
   jsval result;
   if (!JS_NewNumberValue(cx, d, &result))
     return JS_FALSE;
 
   JS_SET_RVAL(cx, vp, result);
   return JS_TRUE;
 }
--- a/js/src/frontend/BytecodeEmitter.cpp
+++ b/js/src/frontend/BytecodeEmitter.cpp
@@ -2296,17 +2296,17 @@ EmitElemIncDec(JSContext *cx, ParseNode 
         return false;
 
     UpdateDecomposeLength(bce, start);
 
     return true;
 }
 
 static JSBool
-EmitNumberOp(JSContext *cx, double dval, BytecodeEmitter *bce)
+EmitNumberOp(JSContext *cx, jsdouble dval, BytecodeEmitter *bce)
 {
     int32_t ival;
     uint32_t u;
     ptrdiff_t off;
     jsbytecode *pc;
 
     if (JSDOUBLE_IS_INT32(dval, &ival)) {
         if (ival == 0)
--- a/js/src/frontend/FoldConstants.cpp
+++ b/js/src/frontend/FoldConstants.cpp
@@ -104,17 +104,17 @@ ContainsVarOrConst(ParseNode *pn)
  */
 static JSBool
 FoldType(JSContext *cx, ParseNode *pn, ParseNodeKind kind)
 {
     if (!pn->isKind(kind)) {
         switch (kind) {
           case PNK_NUMBER:
             if (pn->isKind(PNK_STRING)) {
-                double d;
+                jsdouble d;
                 if (!ToNumber(cx, StringValue(pn->pn_atom), &d))
                     return JS_FALSE;
                 pn->pn_dval = d;
                 pn->setKind(PNK_NUMBER);
                 pn->setOp(JSOP_DOUBLE);
             }
             break;
 
@@ -141,17 +141,17 @@ FoldType(JSContext *cx, ParseNode *pn, P
  * Fold two numeric constants.  Beware that pn1 and pn2 are recycled, unless
  * one of them aliases pn, so you can't safely fetch pn2->pn_next, e.g., after
  * a successful call to this function.
  */
 static JSBool
 FoldBinaryNumeric(JSContext *cx, JSOp op, ParseNode *pn1, ParseNode *pn2,
                   ParseNode *pn, TreeContext *tc)
 {
-    double d, d2;
+    jsdouble d, d2;
     int32_t i, j;
 
     JS_ASSERT(pn1->isKind(PNK_NUMBER) && pn2->isKind(PNK_NUMBER));
     d = pn1->pn_dval;
     d2 = pn2->pn_dval;
     switch (op) {
       case JSOP_LSH:
       case JSOP_RSH:
@@ -817,17 +817,17 @@ js::FoldConstants(JSContext *cx, ParseNo
 
       case PNK_TYPEOF:
       case PNK_VOID:
       case PNK_NOT:
       case PNK_BITNOT:
       case PNK_POS:
       case PNK_NEG:
         if (pn1->isKind(PNK_NUMBER)) {
-            double d;
+            jsdouble d;
 
             /* Operate on one numeric constant. */
             d = pn1->pn_dval;
             switch (pn->getOp()) {
               case JSOP_BITNOT:
                 d = ~js_DoubleToECMAInt32(d);
                 break;
 
--- a/js/src/frontend/ParseNode.h
+++ b/js/src/frontend/ParseNode.h
@@ -614,17 +614,17 @@ struct ParseNode {
             uint32_t    dflags:12,      /* definition/use flags, see below */
                         blockid:20;     /* block number, for subset dominance
                                            computation */
         } name;
         struct {                        /* lexical dependencies + sub-tree */
             AtomDefnMapPtr   defnMap;
             ParseNode        *tree;     /* sub-tree containing name uses */
         } nameset;
-        double        dval;             /* aligned numeric literal value */
+        jsdouble        dval;           /* aligned numeric literal value */
         class {
             friend class LoopControlStatement;
             PropertyName     *label;    /* target of break/continue statement */
         } loopControl;
         class {                         /* E4X <?target data?> XML PI */
             friend class XMLProcessingInstruction;
             PropertyName     *target;   /* non-empty */
             JSAtom           *data;     /* may be empty, never null */
--- a/js/src/frontend/TokenStream.cpp
+++ b/js/src/frontend/TokenStream.cpp
@@ -1727,17 +1727,17 @@ TokenStream::getTokenInternal()
             goto error;
         }
 
         /*
          * Unlike identifiers and strings, numbers cannot contain escaped
          * chars, so we don't need to use tokenbuf.  Instead we can just
          * convert the jschars in userbuf directly to the numeric value.
          */
-        double dval;
+        jsdouble dval;
         const jschar *dummy;
         if (!hasFracOrExp) {
             if (!GetPrefixInteger(cx, numStart, userbuf.addressOfNextRawChar(), 10, &dummy, &dval))
                 goto error;
         } else {
             if (!js_strtod(cx, numStart, userbuf.addressOfNextRawChar(), &dummy, &dval))
                 goto error;
         }
@@ -1818,17 +1818,17 @@ TokenStream::getTokenInternal()
         }
         ungetCharIgnoreEOL(c);
 
         if (c != EOF && IsIdentifierStart(c)) {
             ReportCompileErrorNumber(cx, this, NULL, JSREPORT_ERROR, JSMSG_IDSTART_AFTER_NUMBER);
             goto error;
         }
 
-        double dval;
+        jsdouble dval;
         const jschar *dummy;
         if (!GetPrefixInteger(cx, numStart, userbuf.addressOfNextRawChar(), radix, &dummy, &dval))
             goto error;
         tp->setNumber(dval);
         tt = TOK_NUMBER;
         goto out;
     }
 
--- a/js/src/frontend/TokenStream.h
+++ b/js/src/frontend/TokenStream.h
@@ -317,17 +317,17 @@ struct Token {
         } s;
 
       private:
         friend struct Token;
         struct {                        /* pair for <?target data?> XML PI */
             PropertyName *target;       /* non-empty */
             JSAtom       *data;         /* maybe empty, never null */
         } xmlpi;
-        double          number;         /* floating point number */
+        jsdouble        number;         /* floating point number */
         RegExpFlag      reflags;        /* regexp flags, use tokenbuf to access
                                            regexp chars */
     } u;
 
     /* Mutators */
 
     /*
      * FIXME: Init type early enough such that all mutators can assert
@@ -354,17 +354,17 @@ struct Token {
         u.xmlpi.data = data;
     }
 
     void setRegExpFlags(js::RegExpFlag flags) {
         JS_ASSERT((flags & AllFlags) == flags);
         u.reflags = flags;
     }
 
-    void setNumber(double n) {
+    void setNumber(jsdouble n) {
         u.number = n;
     }
 
     /* Type-safe accessors */
 
     PropertyName *name() const {
         JS_ASSERT(type == TOK_NAME);
         return u.s.n.name->asPropertyName(); /* poor-man's type verification */
@@ -391,17 +391,17 @@ struct Token {
     }
 
     js::RegExpFlag regExpFlags() const {
         JS_ASSERT(type == TOK_REGEXP);
         JS_ASSERT((u.reflags & AllFlags) == u.reflags);
         return u.reflags;
     }
 
-    double number() const {
+    jsdouble number() const {
         JS_ASSERT(type == TOK_NUMBER);
         return u.number;
     }
 };
 
 #define t_op            u.s.op
 
 enum TokenStreamFlags
--- a/js/src/jsapi-tests/testParseJSON.cpp
+++ b/js/src/jsapi-tests/testParseJSON.cpp
@@ -46,17 +46,17 @@ BEGIN_TEST(testParseJSON_success)
     CHECK(TryParse(cx, "false", JSVAL_FALSE));
     CHECK(TryParse(cx, "null", JSVAL_NULL));
     CHECK(TryParse(cx, "0", INT_TO_JSVAL(0)));
     CHECK(TryParse(cx, "1", INT_TO_JSVAL(1)));
     CHECK(TryParse(cx, "-1", INT_TO_JSVAL(-1)));
     CHECK(TryParse(cx, "1", DOUBLE_TO_JSVAL(1)));
     CHECK(TryParse(cx, "1.75", DOUBLE_TO_JSVAL(1.75)));
     CHECK(TryParse(cx, "9e9", DOUBLE_TO_JSVAL(9e9)));
-    CHECK(TryParse(cx, "9e99999", DOUBLE_TO_JSVAL(std::numeric_limits<double>::infinity())));
+    CHECK(TryParse(cx, "9e99999", DOUBLE_TO_JSVAL(std::numeric_limits<jsdouble>::infinity())));
 
     JSFlatString *str;
 
     const jschar emptystr[] = { '\0' };
     str = js_NewStringCopyN(cx, emptystr, 0);
     CHECK(str);
     CHECK(TryParse(cx, "\"\"", STRING_TO_JSVAL(str)));
 
--- a/js/src/jsapi.cpp
+++ b/js/src/jsapi.cpp
@@ -280,17 +280,17 @@ JS_ConvertArguments(JSContext *cx, uintN
 
 JS_PUBLIC_API(JSBool)
 JS_ConvertArgumentsVA(JSContext *cx, uintN argc, jsval *argv, const char *format, va_list ap)
 {
     jsval *sp;
     JSBool required;
     char c;
     JSFunction *fun;
-    double d;
+    jsdouble d;
     JSString *str;
     JSObject *obj;
 
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, JSValueArray(argv - 2, argc + 2));
     sp = argv;
     required = JS_TRUE;
@@ -333,23 +333,23 @@ JS_ConvertArgumentsVA(JSContext *cx, uin
             if (!JS_ValueToECMAUint32(cx, *sp, va_arg(ap, uint32_t *)))
                 return JS_FALSE;
             break;
           case 'j':
             if (!JS_ValueToInt32(cx, *sp, va_arg(ap, int32_t *)))
                 return JS_FALSE;
             break;
           case 'd':
-            if (!JS_ValueToNumber(cx, *sp, va_arg(ap, double *)))
+            if (!JS_ValueToNumber(cx, *sp, va_arg(ap, jsdouble *)))
                 return JS_FALSE;
             break;
           case 'I':
             if (!JS_ValueToNumber(cx, *sp, &d))
                 return JS_FALSE;
-            *va_arg(ap, double *) = js_DoubleToInteger(d);
+            *va_arg(ap, jsdouble *) = js_DoubleToInteger(d);
             break;
           case 'S':
           case 'W':
             str = ToString(cx, *sp);
             if (!str)
                 return JS_FALSE;
             *sp = STRING_TO_JSVAL(str);
             if (c == 'W') {
@@ -440,17 +440,17 @@ JS_RemoveArgumentFormatter(JSContext *cx
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ConvertValue(JSContext *cx, jsval v, JSType type, jsval *vp)
 {
     JSBool ok;
     JSObject *obj;
     JSString *str;
-    double d;
+    jsdouble d;
 
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, v);
     switch (type) {
       case JSTYPE_VOID:
         *vp = JSVAL_VOID;
         ok = JS_TRUE;
@@ -531,40 +531,40 @@ JS_ValueToSource(JSContext *cx, jsval v)
 {
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, v);
     return js_ValueToSource(cx, v);
 }
 
 JS_PUBLIC_API(JSBool)
-JS_ValueToNumber(JSContext *cx, jsval v, double *dp)
+JS_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp)
 {
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, v);
 
     AutoValueRooter tvr(cx, v);
     return ToNumber(cx, tvr.value(), dp);
 }
 
 JS_PUBLIC_API(JSBool)
-JS_DoubleIsInt32(double d, jsint *ip)
+JS_DoubleIsInt32(jsdouble d, jsint *ip)
 {
     return JSDOUBLE_IS_INT32(d, (int32_t *)ip);
 }
 
 JS_PUBLIC_API(int32_t)
-JS_DoubleToInt32(double d)
+JS_DoubleToInt32(jsdouble d)
 {
     return js_DoubleToECMAInt32(d);
 }
 
 JS_PUBLIC_API(uint32_t)
-JS_DoubleToUint32(double d)
+JS_DoubleToUint32(jsdouble d)
 {
     return js_DoubleToECMAUint32(d);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ValueToECMAInt32(JSContext *cx, jsval v, int32_t *ip)
 {
     AssertNoGC(cx);
@@ -2243,17 +2243,17 @@ JS_strdup(JSContext *cx, const char *s)
     size_t n = strlen(s) + 1;
     void *p = cx->malloc_(n);
     if (!p)
         return NULL;
     return (char *)js_memcpy(p, s, n);
 }
 
 JS_PUBLIC_API(JSBool)
-JS_NewNumberValue(JSContext *cx, double d, jsval *rval)
+JS_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval)
 {
     AssertNoGC(cx);
     d = JS_CANONICALIZE_NAN(d);
     rval->setNumber(d);
     return JS_TRUE;
 }
 
 #undef JS_AddRoot
@@ -6280,17 +6280,17 @@ JS_PUBLIC_API(JSObject *)
 JS_NewDateObject(JSContext *cx, int year, int mon, int mday, int hour, int min, int sec)
 {
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     return js_NewDateObject(cx, year, mon, mday, hour, min, sec);
 }
 
 JS_PUBLIC_API(JSObject *)
-JS_NewDateObjectMsec(JSContext *cx, double msec)
+JS_NewDateObjectMsec(JSContext *cx, jsdouble msec)
 {
     AssertNoGC(cx);
     CHECK_REQUEST(cx);
     return js_NewDateObjectMsec(cx, msec);
 }
 
 JS_PUBLIC_API(JSBool)
 JS_ObjectIsDate(JSContext *cx, JSObject *obj)
--- a/js/src/jsapi.h
+++ b/js/src/jsapi.h
@@ -1657,27 +1657,27 @@ INT_TO_JSVAL(int32_t i)
 }
 
 static JS_ALWAYS_INLINE JSBool
 JSVAL_IS_DOUBLE(jsval v)
 {
     return JSVAL_IS_DOUBLE_IMPL(JSVAL_TO_IMPL(v));
 }
 
-static JS_ALWAYS_INLINE double
+static JS_ALWAYS_INLINE jsdouble
 JSVAL_TO_DOUBLE(jsval v)
 {
     jsval_layout l;
     JS_ASSERT(JSVAL_IS_DOUBLE(v));
     l = JSVAL_TO_IMPL(v);
     return l.asDouble;
 }
 
 static JS_ALWAYS_INLINE jsval
-DOUBLE_TO_JSVAL(double d)
+DOUBLE_TO_JSVAL(jsdouble d)
 {
     /* This is a manually inlined version of:
      *    d = JS_CANONICALIZE_NAN(d);
      *    return IMPL_TO_JSVAL(DOUBLE_TO_JSVAL_IMPL(d));
      * because GCC from XCode 3.1.4 miscompiles the above code. */
     jsval_layout l;
     if (JS_UNLIKELY(d != d)) {
         l.asBits = 0x7FF8000000000000LL;
@@ -1687,17 +1687,17 @@ DOUBLE_TO_JSVAL(double d)
     return IMPL_TO_JSVAL(l);
 }
 
 static JS_ALWAYS_INLINE jsval
 UINT_TO_JSVAL(uint32_t i)
 {
     if (i <= JSVAL_INT_MAX)
         return INT_TO_JSVAL((int32_t)i);
-    return DOUBLE_TO_JSVAL((double)i);
+    return DOUBLE_TO_JSVAL((jsdouble)i);
 }
 
 static JS_ALWAYS_INLINE JSBool
 JSVAL_IS_NUMBER(jsval v)
 {
     return JSVAL_IS_NUMBER_IMPL(JSVAL_TO_IMPL(v));
 }
 
@@ -2126,18 +2126,18 @@ JS_GetEmptyString(JSRuntime *rt);
  * Format is a string of the following characters (spaces are insignificant),
  * specifying the tabulated type conversions:
  *
  *   b      JSBool          Boolean
  *   c      uint16_t/jschar ECMA uint16_t, Unicode char
  *   i      int32_t         ECMA int32_t
  *   u      uint32_t        ECMA uint32_t
  *   j      int32_t         Rounded int32_t (coordinate)
- *   d      double          IEEE double
- *   I      double          Integral IEEE double
+ *   d      jsdouble        IEEE double
+ *   I      jsdouble        Integral IEEE double
  *   S      JSString *      Unicode string, accessed by a JSString pointer
  *   W      jschar *        Unicode character vector, 0-terminated (W for wide)
  *   o      JSObject *      Object reference
  *   f      JSFunction *    Function private
  *   v      jsval           Argument value (no conversion)
  *   *      N/A             Skip this argument (no vararg)
  *   /      N/A             End of required arguments
  *
@@ -2228,26 +2228,26 @@ JS_ValueToConstructor(JSContext *cx, jsv
 
 extern JS_PUBLIC_API(JSString *)
 JS_ValueToString(JSContext *cx, jsval v);
 
 extern JS_PUBLIC_API(JSString *)
 JS_ValueToSource(JSContext *cx, jsval v);
 
 extern JS_PUBLIC_API(JSBool)
-JS_ValueToNumber(JSContext *cx, jsval v, double *dp);
+JS_ValueToNumber(JSContext *cx, jsval v, jsdouble *dp);
 
 extern JS_PUBLIC_API(JSBool)
-JS_DoubleIsInt32(double d, jsint *ip);
+JS_DoubleIsInt32(jsdouble d, jsint *ip);
 
 extern JS_PUBLIC_API(int32_t)
-JS_DoubleToInt32(double d);
+JS_DoubleToInt32(jsdouble d);
 
 extern JS_PUBLIC_API(uint32_t)
-JS_DoubleToUint32(double d);
+JS_DoubleToUint32(jsdouble d);
 
 /*
  * Convert a value to a number, then to an int32_t, according to the ECMA rules
  * for ToInt32.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_ValueToECMAInt32(JSContext *cx, jsval v, int32_t *ip);
 
@@ -2889,17 +2889,17 @@ JS_free(JSContext *cx, void *p);
 
 extern JS_PUBLIC_API(void)
 JS_updateMallocCounter(JSContext *cx, size_t nbytes);
 
 extern JS_PUBLIC_API(char *)
 JS_strdup(JSContext *cx, const char *s);
 
 extern JS_PUBLIC_API(JSBool)
-JS_NewNumberValue(JSContext *cx, double d, jsval *rval);
+JS_NewNumberValue(JSContext *cx, jsdouble d, jsval *rval);
 
 /*
  * A GC root is a pointer to a jsval, JSObject * or JSString * that itself
  * points into the GC heap. JS_AddValueRoot takes a pointer to a jsval and
  * JS_AddGCThingRoot takes a pointer to a JSObject * or JString *.
  *
  * Note that, since JS_Add*Root stores the address of a variable (of type
  * jsval, JSString *, or JSObject *), that variable must live until
@@ -3591,17 +3591,17 @@ JS_ResolveStub(JSContext *cx, JSObject *
 
 extern JS_PUBLIC_API(JSBool)
 JS_ConvertStub(JSContext *cx, JSObject *obj, JSType type, jsval *vp);
 
 extern JS_PUBLIC_API(void)
 JS_FinalizeStub(JSContext *cx, JSObject *obj);
 
 struct JSConstDoubleSpec {
-    double          dval;
+    jsdouble        dval;
     const char      *name;
     uint8_t         flags;
     uint8_t         spare[3];
 };
 
 /*
  * To define an array element rather than a named property member, cast the
  * element's index to (const char *) and initialize name with it, and set the
@@ -5167,17 +5167,17 @@ JS_SetErrorReporter(JSContext *cx, JSErr
 /*
  * Dates.
  */
 
 extern JS_PUBLIC_API(JSObject *)
 JS_NewDateObject(JSContext *cx, int year, int mon, int mday, int hour, int min, int sec);
 
 extern JS_PUBLIC_API(JSObject *)
-JS_NewDateObjectMsec(JSContext *cx, double msec);
+JS_NewDateObjectMsec(JSContext *cx, jsdouble msec);
 
 /*
  * Infallible predicate to test whether obj is a date object.
  */
 extern JS_PUBLIC_API(JSBool)
 JS_ObjectIsDate(JSContext *cx, JSObject *obj);
 
 /************************************************************************/
--- a/js/src/jsarray.cpp
+++ b/js/src/jsarray.cpp
@@ -300,23 +300,23 @@ JSObject::willBeSparseDenseArray(uintN r
     for (uintN i = 0; i < len; i++) {
         if (!elems[i].isMagic(JS_ARRAY_HOLE) && !--minimalDenseCount)
             return false;
     }
     return true;
 }
 
 static bool
-ReallyBigIndexToId(JSContext* cx, double index, jsid* idp)
+ReallyBigIndexToId(JSContext* cx, jsdouble index, jsid* idp)
 {
     return js_ValueToStringId(cx, DoubleValue(index), idp);
 }
 
 static bool
-IndexToId(JSContext* cx, JSObject* obj, double index, JSBool* hole, jsid* idp,
+IndexToId(JSContext* cx, JSObject* obj, jsdouble index, JSBool* hole, jsid* idp,
           JSBool createAtom = JS_FALSE)
 {
     if (index <= JSID_INT_MAX) {
         *idp = INT_TO_JSID(int(index));
         return JS_TRUE;
     }
 
     if (index <= jsuint(-1)) {
@@ -358,17 +358,17 @@ JSObject::arrayGetOwnDataElement(JSConte
 
 /*
  * If the property at the given index exists, get its value into location
  * pointed by vp and set *hole to false. Otherwise set *hole to true and *vp
  * to JSVAL_VOID. This function assumes that the location pointed by vp is
  * properly rooted and can be used as GC-protected storage for temporaries.
  */
 static inline JSBool
-DoGetElement(JSContext *cx, JSObject *obj, double index, JSBool *hole, Value *vp)
+DoGetElement(JSContext *cx, JSObject *obj, jsdouble index, JSBool *hole, Value *vp)
 {
     AutoIdRooter idr(cx);
 
     *hole = JS_FALSE;
     if (!IndexToId(cx, obj, index, hole, idr.addr()))
         return JS_FALSE;
     if (*hole) {
         vp->setUndefined();
@@ -463,17 +463,17 @@ GetElements(JSContext *cx, JSObject *aob
 }
 
 }
 
 /*
  * Set the value of the property at the given index to v assuming v is rooted.
  */
 static JSBool
-SetArrayElement(JSContext *cx, JSObject *obj, double index, const Value &v)
+SetArrayElement(JSContext *cx, JSObject *obj, jsdouble index, const Value &v)
 {
     JS_ASSERT(index >= 0);
 
     if (obj->isDenseArray()) {
         /* Predicted/prefetched code should favor the remains-dense case. */
         JSObject::EnsureDenseResult result = JSObject::ED_SPARSE;
         do {
             if (index > jsuint(-1))
@@ -514,17 +514,17 @@ SetArrayElement(JSContext *cx, JSObject 
  *
  * - Return 0 if the deletion fails because the property is not
  *   configurable (that is, [[Delete]] would return false). Note that if
  *   |strict| is true we will throw, not return zero.
  *
  * - Return -1 if an exception occurs (that is, [[Delete]] would throw).
  */
 static int
-DeleteArrayElement(JSContext *cx, JSObject *obj, double index, bool strict)
+DeleteArrayElement(JSContext *cx, JSObject *obj, jsdouble index, bool strict)
 {
     JS_ASSERT(index >= 0);
     JS_ASSERT(floor(index) == index);
 
     if (obj->isDenseArray()) {
         if (index <= UINT32_MAX) {
             uint32_t idx = uint32_t(index);
             if (idx < obj->getDenseArrayInitializedLength()) {
@@ -549,28 +549,28 @@ DeleteArrayElement(JSContext *cx, JSObje
     return v.isTrue() ? 1 : 0;
 }
 
 /*
  * When hole is true, delete the property at the given index. Otherwise set
  * its value to v assuming v is rooted.
  */
 static JSBool
-SetOrDeleteArrayElement(JSContext *cx, JSObject *obj, double index,
+SetOrDeleteArrayElement(JSContext *cx, JSObject *obj, jsdouble index,
                         JSBool hole, const Value &v)
 {
     if (hole) {
         JS_ASSERT(v.isUndefined());
         return DeleteArrayElement(cx, obj, index, true) >= 0;
     }
     return SetArrayElement(cx, obj, index, v);
 }
 
 JSBool
-js_SetLengthProperty(JSContext *cx, JSObject *obj, double length)
+js_SetLengthProperty(JSContext *cx, JSObject *obj, jsdouble length)
 {
     Value v = NumberValue(length);
 
     /* We don't support read-only array length yet. */
     return obj->setProperty(cx, cx->runtime->atomState.lengthAtom, &v, false);
 }
 
 /*
@@ -599,17 +599,17 @@ array_length_setter(JSContext *cx, JSObj
         return obj->defineProperty(cx, cx->runtime->atomState.lengthAtom, *vp,
                                    NULL, NULL, JSPROP_ENUMERATE);
     }
 
     uint32_t newlen;
     if (!ToUint32(cx, *vp, &newlen))
         return false;
 
-    double d;
+    jsdouble d;
     if (!ToNumber(cx, *vp, &d))
         return false;
 
     if (d != newlen) {
         JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_ARRAY_LENGTH);
         return false;
     }
 
@@ -2163,17 +2163,17 @@ SortComparatorFunction::operator()(const
     ag.setCallee(fval);
     ag.thisv() = UndefinedValue();
     ag[0] = a;
     ag[1] = b;
 
     if (!Invoke(cx, ag))
         return false;
 
-    double cmp;
+    jsdouble cmp;
     if (!ToNumber(cx, ag.rval(), &cmp))
         return false;
 
     /*
      * XXX eport some kind of error here if cmp is NaN? ECMA talks about
      * 'consistent compare functions' that don't return NaN, but is silent
      * about what the result should be. So we currently ignore it.
      */
@@ -2369,17 +2369,17 @@ array_push_slowly(JSContext *cx, JSObjec
     jsuint length;
 
     if (!js_GetLengthProperty(cx, obj, &length))
         return false;
     if (!InitArrayElements(cx, obj, length, args.length(), args.array(), UpdateTypes))
         return false;
 
     /* Per ECMA-262, return the new array length. */
-    double newlength = length + double(args.length());
+    jsdouble newlength = length + jsdouble(args.length());
     args.rval().setNumber(newlength);
     return js_SetLengthProperty(cx, obj, newlength);
 }
 
 static bool
 array_push1_dense(JSContext* cx, JSObject* obj, CallArgs &args)
 {
     JS_ASSERT(args.length() == 1);
@@ -2588,17 +2588,17 @@ array_unshift(JSContext *cx, uintN argc,
     JSObject *obj = ToObject(cx, &args.thisv());
     if (!obj)
         return false;
 
     jsuint length;
     if (!js_GetLengthProperty(cx, obj, &length))
         return JS_FALSE;
 
-    double newlen = length;
+    jsdouble newlen = length;
     if (args.length() > 0) {
         /* Slide up the array to make room for all args at the bottom. */
         if (length > 0) {
             bool optimized = false;
             do {
                 if (!obj->isDenseArray())
                     break;
                 if (js_PrototypeHasIndexedProperties(cx, obj))
@@ -2612,18 +2612,18 @@ array_unshift(JSContext *cx, uintN argc,
                 }
                 obj->moveDenseArrayElements(args.length(), 0, length);
                 for (uint32_t i = 0; i < args.length(); i++)
                     obj->setDenseArrayElement(i, MagicValue(JS_ARRAY_HOLE));
                 optimized = true;
             } while (false);
 
             if (!optimized) {
-                double last = length;
-                double upperIndex = last + args.length();
+                jsdouble last = length;
+                jsdouble upperIndex = last + args.length();
                 AutoValueRooter tvr(cx);
                 do {
                     --last, --upperIndex;
                     JSBool hole;
                     if (!JS_CHECK_OPERATION_LIMIT(cx) ||
                         !GetElement(cx, obj, last, &hole, tvr.addr()) ||
                         !SetOrDeleteArrayElement(cx, obj, upperIndex, hole, tvr.value())) {
                         return JS_FALSE;
@@ -2726,17 +2726,17 @@ array_splice(JSContext *cx, uintN argc, 
     if (relativeStart < 0)
         actualStart = JS_MAX(len + relativeStart, 0);
     else
         actualStart = JS_MIN(relativeStart, len);
 
     /* Step 7. */
     uint32_t actualDeleteCount;
     if (argc != 1) {
-        double deleteCountDouble;
+        jsdouble deleteCountDouble;
         if (!ToInteger(cx, argc >= 2 ? args[1] : Int32Value(0), &deleteCountDouble))
             return false;
         actualDeleteCount = JS_MIN(JS_MAX(deleteCountDouble, 0), len - actualStart);
     } else {
         /*
          * Non-standard: if start was specified but deleteCount was omitted,
          * delete to the end of the array.  See bug 668024 for discussion.
          */
@@ -2848,19 +2848,19 @@ array_splice(JSContext *cx, uintN argc, 
         if (CanOptimizeForDenseStorage(obj, len, itemCount - actualDeleteCount, cx)) {
             obj->moveDenseArrayElements(actualStart + itemCount,
                                         actualStart + actualDeleteCount,
                                         len - (actualStart + actualDeleteCount));
 
             if (cx->typeInferenceEnabled())
                 obj->setDenseArrayInitializedLength(len + itemCount - actualDeleteCount);
         } else {
-            for (double k = len - actualDeleteCount; k > actualStart; k--) {
-                double from = k + actualDeleteCount - 1;
-                double to = k + itemCount - 1;
+            for (jsdouble k = len - actualDeleteCount; k > actualStart; k--) {
+                jsdouble from = k + actualDeleteCount - 1;
+                jsdouble to = k + itemCount - 1;
 
                 JSBool hole;
                 Value fromValue;
                 if (!JS_CHECK_OPERATION_LIMIT(cx) ||
                     !GetElement(cx, obj, from, &hole, &fromValue) ||
                     !SetOrDeleteArrayElement(cx, obj, to, hole, fromValue))
                 {
                     return false;
@@ -2874,17 +2874,17 @@ array_splice(JSContext *cx, uintN argc, 
 
     /* Steps 14-15. */
     for (uint32_t k = actualStart, i = 0; i < itemCount; i++, k++) {
         if (!SetArrayElement(cx, obj, k, items[i]))
             return false;
     }
 
     /* Step 16. */
-    double finalLength = double(len) - actualDeleteCount + itemCount;
+    jsdouble finalLength = jsdouble(len) - actualDeleteCount + itemCount;
     if (!js_SetLengthProperty(cx, obj, finalLength))
         return false;
 
     /* Step 17. */
     args.rval().setObject(*arr);
     return true;
 }
 
@@ -3009,17 +3009,17 @@ array_slice(JSContext *cx, uintN argc, V
         return false;
 
     if (!js_GetLengthProperty(cx, obj, &length))
         return JS_FALSE;
     begin = 0;
     end = length;
 
     if (args.length() > 0) {
-        double d;
+        jsdouble d;
         if (!ToInteger(cx, args[0], &d))
             return false;
         if (d < 0) {
             d += length;
             if (d < 0)
                 d = 0;
         } else if (d > length) {
             d = length;
@@ -3092,17 +3092,17 @@ array_indexOfHelper(JSContext *cx, Index
         return JS_FALSE;
     if (length == 0)
         goto not_found;
 
     if (args.length() <= 1) {
         i = (mode == LastIndexOf) ? length - 1 : 0;
         tosearch = (args.length() != 0) ? args[0] : UndefinedValue();
     } else {
-        double start;
+        jsdouble start;
 
         tosearch = args[0];
         if (!ToInteger(cx, args[1], &start))
             return false;
         if (start < 0) {
             start += length;
             if (start < 0) {
                 if (mode == LastIndexOf)
@@ -3658,19 +3658,19 @@ js_Array(JSContext *cx, uintN argc, Valu
     if (args[0].isInt32()) {
         int32_t i = args[0].toInt32();
         if (i < 0) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_ARRAY_LENGTH);
             return false;
         }
         length = uint32_t(i);
     } else {
-        double d = args[0].toDouble();
+        jsdouble d = args[0].toDouble();
         length = js_DoubleToECMAUint32(d);
-        if (d != double(length)) {
+        if (d != jsdouble(length)) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_ARRAY_LENGTH);
             return false;
         }
     }
 
     JSObject *obj = NewDenseUnallocatedArray(cx, length);
     if (!obj)
         return false;
--- a/js/src/jsarray.h
+++ b/js/src/jsarray.h
@@ -136,17 +136,17 @@ extern JSObject *
 NewSlowEmptyArray(JSContext *cx);
 
 } /* namespace js */
 
 extern JSBool
 js_GetLengthProperty(JSContext *cx, JSObject *obj, jsuint *lengthp);
 
 extern JSBool
-js_SetLengthProperty(JSContext *cx, JSObject *obj, double length);
+js_SetLengthProperty(JSContext *cx, JSObject *obj, jsdouble length);
 
 namespace js {
 
 extern JSBool
 array_defineElement(JSContext *cx, JSObject *obj, uint32_t index, const Value *value,
                     PropertyOp getter, StrictPropertyOp setter, uintN attrs);
 
 extern JSBool
--- a/js/src/jsbool.cpp
+++ b/js/src/jsbool.cpp
@@ -227,16 +227,16 @@ js_ValueToBoolean(const Value &v)
         return v.toInt32() != 0;
     if (v.isString())
         return v.toString()->length() != 0;
     if (v.isObject())
         return JS_TRUE;
     if (v.isNullOrUndefined())
         return JS_FALSE;
     if (v.isDouble()) {
-        double d;
+        jsdouble d;
 
         d = v.toDouble();
         return !JSDOUBLE_IS_NaN(d) && d != 0;
     }
     JS_ASSERT(v.isBoolean());
     return v.toBoolean();
 }
--- a/js/src/jsclone.cpp
+++ b/js/src/jsclone.cpp
@@ -190,21 +190,21 @@ SCInput::readPair(uint32_t *tagp, uint32
  */
 static JS_NEVER_INLINE double
 CanonicalizeNan(double d)
 {
     return JS_CANONICALIZE_NAN(d);
 }
 
 bool
-SCInput::readDouble(double *p)
+SCInput::readDouble(jsdouble *p)
 {
     union {
         uint64_t u;
-        double d;
+        jsdouble d;
     } pun;
     if (!read(&pun.u))
         return false;
     *p = CanonicalizeNan(pun.d);
     return true;
 }
 
 template <class T>
@@ -260,56 +260,56 @@ PairToUInt64(uint32_t tag, uint32_t data
     return uint64_t(data) | (uint64_t(tag) << 32);
 }
 
 bool
 SCOutput::writePair(uint32_t tag, uint32_t data)
 {
     /*
      * As it happens, the tag word appears after the data word in the output.
-     * This is because exponents occupy the last 2 bytes of doubles on the
+     * This is because exponents occupy the last 2 bytes of jsdoubles on the
      * little-endian platforms we care most about.
      *
      * For example, JSVAL_TRUE is written using writePair(SCTAG_BOOLEAN, 1).
      * PairToUInt64 produces the number 0xFFFF000200000001.
      * That is written out as the bytes 01 00 00 00 02 00 FF FF.
      */
     return write(PairToUInt64(tag, data));
 }
 
 static inline uint64_t
-ReinterpretDoubleAsUInt64(double d)
+ReinterpretDoubleAsUInt64(jsdouble d)
 {
     union {
-        double d;
+        jsdouble d;
         uint64_t u;
     } pun;
     pun.d = d;
     return pun.u;
 }
 
-static inline double
+static inline jsdouble
 ReinterpretUInt64AsDouble(uint64_t u)
 {
     union {
         uint64_t u;
-        double d;
+        jsdouble d;
     } pun;
     pun.u = u;
     return pun.d;
 }
 
-static inline double
+static inline jsdouble
 ReinterpretPairAsDouble(uint32_t tag, uint32_t data)
 {
     return ReinterpretUInt64AsDouble(PairToUInt64(tag, data));
 }
 
 bool
-SCOutput::writeDouble(double d)
+SCOutput::writeDouble(jsdouble d)
 {
     return write(ReinterpretDoubleAsUInt64(CanonicalizeNan(d)));
 }
 
 template <class T>
 bool
 SCOutput::writeArray(const T *p, size_t nelems)
 {
@@ -525,17 +525,17 @@ JSStructuredCloneWriter::startWrite(cons
         return out.writePair(SCTAG_UNDEFINED, 0);
     } else if (v.isObject()) {
         JSObject *obj = &v.toObject();
         if (obj->isRegExp()) {
             RegExpObject &reobj = obj->asRegExp();
             return out.writePair(SCTAG_REGEXP_OBJECT, reobj.getFlags()) &&
                    writeString(SCTAG_STRING, reobj.getSource());
         } else if (obj->isDate()) {
-            double d = js_DateGetMsecSinceEpoch(context(), obj);
+            jsdouble d = js_DateGetMsecSinceEpoch(context(), obj);
             return out.writePair(SCTAG_DATE_OBJECT, 0) && out.writeDouble(d);
         } else if (obj->isObject() || obj->isArray()) {
             return startObject(obj);
         } else if (js_IsTypedArray(obj)) {
             return writeTypedArray(obj);
         } else if (js_IsArrayBuffer(obj)) {
             return writeArrayBuffer(obj);
         } else if (obj->isBoolean()) {
@@ -598,17 +598,17 @@ JSStructuredCloneWriter::write(const Val
     }
 
     memory.clear();
 
     return true;
 }
 
 bool
-JSStructuredCloneReader::checkDouble(double d)
+JSStructuredCloneReader::checkDouble(jsdouble d)
 {
     jsval_layout l;
     l.asDouble = d;
     if (!JSVAL_IS_DOUBLE_IMPL(l)) {
         JS_ReportErrorNumber(context(), js_GetErrorMessage, NULL,
                              JSMSG_SC_BAD_SERIALIZED_DATA, "unrecognized NaN");
         return false;
     }
@@ -726,27 +726,27 @@ JSStructuredCloneReader::startRead(Value
             return false;
         vp->setString(str);
         if (tag == SCTAG_STRING_OBJECT && !js_PrimitiveToObject(context(), vp))
             return false;
         break;
       }
 
       case SCTAG_NUMBER_OBJECT: {
-        double d;
+        jsdouble d;
         if (!in.readDouble(&d) || !checkDouble(d))
             return false;
         vp->setDouble(d);
         if (!js_PrimitiveToObject(context(), vp))
             return false;
         break;
       }
 
       case SCTAG_DATE_OBJECT: {
-        double d;
+        jsdouble d;
         if (!in.readDouble(&d) || !checkDouble(d))
             return false;
         if (d == d && d != TIMECLIP(d)) {
             JS_ReportErrorNumber(context(), js_GetErrorMessage, NULL, JSMSG_SC_BAD_SERIALIZED_DATA,
                                  "date");
             return false;
         }
         JSObject *obj = js_NewDateObjectMsec(context(), d);
@@ -803,17 +803,17 @@ JSStructuredCloneReader::startRead(Value
         break;
       }
 
       case SCTAG_ARRAY_BUFFER_OBJECT:
         return readArrayBuffer(data, vp);
 
       default: {
         if (tag <= SCTAG_FLOAT_MAX) {
-            double d = ReinterpretPairAsDouble(tag, data);
+            jsdouble d = ReinterpretPairAsDouble(tag, data);
             if (!checkDouble(d))
                 return false;
             vp->setNumber(d);
             break;
         }
 
         if (SCTAG_TYPED_ARRAY_MIN <= tag && tag <= SCTAG_TYPED_ARRAY_MAX)
             return readTypedArray(tag, data, vp);
--- a/js/src/jsclone.h
+++ b/js/src/jsclone.h
@@ -58,17 +58,17 @@ ReadStructuredClone(JSContext *cx, const
 struct SCOutput {
   public:
     explicit SCOutput(JSContext *cx);
 
     JSContext *context() const { return cx; }
 
     bool write(uint64_t u);
     bool writePair(uint32_t tag, uint32_t data);
-    bool writeDouble(double d);
+    bool writeDouble(jsdouble d);
     bool writeBytes(const void *p, size_t nbytes);
     bool writeChars(const jschar *p, size_t nchars);
 
     template <class T>
     bool writeArray(const T *p, size_t nbytes);
 
     bool extractBuffer(uint64_t **datap, size_t *sizep);
 
@@ -82,30 +82,30 @@ struct SCOutput {
 struct SCInput {
   public:
     SCInput(JSContext *cx, const uint64_t *data, size_t nbytes);
 
     JSContext *context() const { return cx; }
 
     bool read(uint64_t *p);
     bool readPair(uint32_t *tagp, uint32_t *datap);
-    bool readDouble(double *p);
+    bool readDouble(jsdouble *p);
     bool readBytes(void *p, size_t nbytes);
     bool readChars(jschar *p, size_t nchars);
 
     template <class T>
     bool readArray(T *p, size_t nelems);
 
   private:
     bool eof();
 
     void staticAssertions() {
         JS_STATIC_ASSERT(sizeof(jschar) == 2);
         JS_STATIC_ASSERT(sizeof(uint32_t) == 4);
-        JS_STATIC_ASSERT(sizeof(double) == 8);
+        JS_STATIC_ASSERT(sizeof(jsdouble) == 8);
     }
 
     JSContext *cx;
     const uint64_t *point;
     const uint64_t *end;
 };
 
 }
@@ -118,17 +118,17 @@ struct JSStructuredCloneReader {
           callbacks(cb), closure(cbClosure) { }
 
     js::SCInput &input() { return in; }
     bool read(js::Value *vp);
 
   private:
     JSContext *context() { return in.context(); }
 
-    bool checkDouble(double d);
+    bool checkDouble(jsdouble d);
     JSString *readString(uint32_t nchars);
     bool readTypedArray(uint32_t tag, uint32_t nelems, js::Value *vp);
     bool readArrayBuffer(uint32_t nbytes, js::Value *vp);
     bool readId(jsid *idp);
     bool startRead(js::Value *vp);
 
     js::SCInput &in;
 
--- a/js/src/jsdate.cpp
+++ b/js/src/jsdate.cpp
@@ -171,33 +171,33 @@ using namespace js::types;
 #define SecondsPerMinute 60.0
 
 #if defined(XP_WIN) || defined(XP_OS2)
 /* Work around msvc double optimization bug by making these runtime values; if
  * they're available at compile time, msvc optimizes division by them by
  * computing the reciprocal and multiplying instead of dividing - this loses
  * when the reciprocal isn't representable in a double.
  */
-static double msPerSecond = 1000.0;
-static double msPerDay = SecondsPerDay * 1000.0;
-static double msPerHour = SecondsPerHour * 1000.0;
-static double msPerMinute = SecondsPerMinute * 1000.0;
+static jsdouble msPerSecond = 1000.0;
+static jsdouble msPerDay = SecondsPerDay * 1000.0;
+static jsdouble msPerHour = SecondsPerHour * 1000.0;
+static jsdouble msPerMinute = SecondsPerMinute * 1000.0;
 #else
 #define msPerDay        (SecondsPerDay * msPerSecond)
 #define msPerHour       (SecondsPerHour * msPerSecond)
 #define msPerMinute     (SecondsPerMinute * msPerSecond)
 #define msPerSecond     1000.0
 #endif
 
 #define Day(t)          floor((t) / msPerDay)
 
-static double
-TimeWithinDay(double t)
+static jsdouble
+TimeWithinDay(jsdouble t)
 {
-    double result;
+    jsdouble result;
     result = fmod(t, msPerDay);
     if (result < 0)
         result += msPerDay;
     return result;
 }
 
 static inline bool
 IsLeapYear(jsint year)
@@ -220,20 +220,20 @@ DaysInFebruary(jsint year)
 /* math here has to be f.p, because we need
  *  floor((1968 - 1969) / 4) == -1
  */
 #define DayFromYear(y)  (365 * ((y)-1970) + floor(((y)-1969)/4.0)            \
                          - floor(((y)-1901)/100.0) + floor(((y)-1601)/400.0))
 #define TimeFromYear(y) (DayFromYear(y) * msPerDay)
 
 static jsint
-YearFromTime(double t)
+YearFromTime(jsdouble t)
 {
     jsint y = (jsint) floor(t /(msPerDay*365.2425)) + 1970;
-    double t2 = (double) TimeFromYear(y);
+    jsdouble t2 = (jsdouble) TimeFromYear(y);
 
     /*
      * Adjust the year if the approximation was wrong.  Since the year was
      * computed using the average number of ms per year, it will usually
      * be wrong for dates within several hours of a year transition.
      */
     if (t2 > t) {
         y--;
@@ -245,33 +245,33 @@ YearFromTime(double t)
 }
 
 #define DayWithinYear(t, year) ((intN) (Day(t) - DayFromYear(year)))
 
 /*
  * The following array contains the day of year for the first day of
  * each month, where index 0 is January, and day 0 is January 1.
  */
-static double firstDayOfMonth[2][13] = {
+static jsdouble firstDayOfMonth[2][13] = {
     {0.0, 31.0, 59.0, 90.0, 120.0, 151.0, 181.0, 212.0, 243.0, 273.0, 304.0, 334.0, 365.0},
     {0.0, 31.0, 60.0, 91.0, 121.0, 152.0, 182.0, 213.0, 244.0, 274.0, 305.0, 335.0, 366.0}
 };
 
 #define DayFromMonth(m, leap) firstDayOfMonth[leap][(intN)m]
 
 static intN
 DaysInMonth(jsint year, jsint month)
 {
     JSBool leap = IsLeapYear(year);
     intN result = intN(DayFromMonth(month, leap) - DayFromMonth(month-1, leap));
     return result;
 }
 
 static intN
-MonthFromTime(double t)
+MonthFromTime(jsdouble t)
 {
     intN d, step;
     jsint year = YearFromTime(t);
     d = DayWithinYear(t, year);
 
     if (d < (step = 31))
         return 0;
     if (d < (step += DaysInFebruary(year)))
@@ -293,17 +293,17 @@ MonthFromTime(double t)
     if (d < (step += 31))
         return 9;
     if (d < (step += 30))
         return 10;
     return 11;
 }
 
 static intN
-DateFromTime(double t)
+DateFromTime(jsdouble t)
 {
     intN d, step, next;
     jsint year = YearFromTime(t);
     d = DayWithinYear(t, year);
 
     if (d <= (next = 30))
         return d + 1;
     step = next;
@@ -336,35 +336,35 @@ DateFromTime(double t)
     step = next;
     if (d <= (next += 30))
         return d - step;
     step = next;
     return d - step;
 }
 
 static intN
-WeekDay(double t)
+WeekDay(jsdouble t)
 {
     jsint result;
     result = (jsint) Day(t) + 4;
     result = result % 7;
     if (result < 0)
         result += 7;
     return (intN) result;
 }
 
 #define MakeTime(hour, min, sec, ms) \
 ((((hour) * MinutesPerHour + (min)) * SecondsPerMinute + (sec)) * msPerSecond + (ms))
 
-static double
-MakeDay(double year, double month, double date)
+static jsdouble
+MakeDay(jsdouble year, jsdouble month, jsdouble date)
 {
     JSBool leap;
-    double yearday;
-    double monthday;
+    jsdouble yearday;
+    jsdouble monthday;
 
     year += floor(month / 12);
 
     month = fmod(month, 12.0);
     if (month < 0)
         month += 12;
 
     leap = IsLeapYear((jsint) year);
@@ -407,89 +407,89 @@ EquivalentYearForDST(jsint year)
     day = day % 7;
     if (day < 0)
         day += 7;
 
     return yearStartingWith[IsLeapYear(year)][day];
 }
 
 /* LocalTZA gets set by js_InitDateClass() */
-static double LocalTZA;
-
-static double
-DaylightSavingTA(double t, JSContext *cx)
+static jsdouble LocalTZA;
+
+static jsdouble
+DaylightSavingTA(jsdouble t, JSContext *cx)
 {
     /* abort if NaN */
     if (JSDOUBLE_IS_NaN(t))
         return t;
 
     /*
      * If earlier than 1970 or after 2038, potentially beyond the ken of
      * many OSes, map it to an equivalent year before asking.
      */
     if (t < 0.0 || t > 2145916800000.0) {
         jsint year = EquivalentYearForDST(YearFromTime(t));
-        double day = MakeDay(year, MonthFromTime(t), DateFromTime(t));
+        jsdouble day = MakeDay(year, MonthFromTime(t), DateFromTime(t));
         t = MakeDate(day, TimeWithinDay(t));
     }
 
     int64_t timeMilliseconds = static_cast<int64_t>(t);
     int64_t offsetMilliseconds = cx->dstOffsetCache.getDSTOffsetMilliseconds(timeMilliseconds, cx);
-    return static_cast<double>(offsetMilliseconds);
+    return static_cast<jsdouble>(offsetMilliseconds);
 }
 
-static double
-AdjustTime(double date, JSContext *cx)
+static jsdouble
+AdjustTime(jsdouble date, JSContext *cx)
 {
-    double t = DaylightSavingTA(date, cx) + LocalTZA;
+    jsdouble t = DaylightSavingTA(date, cx) + LocalTZA;
     t = (LocalTZA >= 0) ? fmod(t, msPerDay) : -fmod(msPerDay - t, msPerDay);
     return t;
 }
 
-static double
-LocalTime(double t, JSContext *cx)
+static jsdouble
+LocalTime(jsdouble t, JSContext *cx)
 {
     return t + AdjustTime(t, cx);
 }
 
-static double
-UTC(double t, JSContext *cx)
+static jsdouble
+UTC(jsdouble t, JSContext *cx)
 {
     return t - AdjustTime(t - LocalTZA, cx);
 }
 
 static intN
-HourFromTime(double t)
+HourFromTime(jsdouble t)
 {
     intN result = (intN) fmod(floor(t/msPerHour), HoursPerDay);
     if (result < 0)
         result += (intN)HoursPerDay;
     return result;
 }
 
 static intN
-MinFromTime(double t)
+MinFromTime(jsdouble t)
 {
     intN result = (intN) fmod(floor(t / msPerMinute), MinutesPerHour);
     if (result < 0)
         result += (intN)MinutesPerHour;
     return result;
 }
 
 static intN
-SecFromTime(double t)
+SecFromTime(jsdouble t)
 {
     intN result = (intN) fmod(floor(t / msPerSecond), SecondsPerMinute);
     if (result < 0)
         result += (intN)SecondsPerMinute;
     return result;
 }
 
 static intN
-msFromTime(double t)
+msFromTime(jsdouble t)
 {
     intN result = (intN) fmod(t, msPerSecond);
     if (result < 0)
         result += (intN)msPerSecond;
     return result;
 }
 
 /**
@@ -573,43 +573,43 @@ date_regionMatches(const char* s1, int s
     if (count == 0) {
         result = JS_TRUE;
     }
 
     return result;
 }
 
 /* find UTC time from given date... no 1900 correction! */
-static double
-date_msecFromDate(double year, double mon, double mday, double hour,
-                  double min, double sec, double msec)
+static jsdouble
+date_msecFromDate(jsdouble year, jsdouble mon, jsdouble mday, jsdouble hour,
+                  jsdouble min, jsdouble sec, jsdouble msec)
 {
-    double day;
-    double msec_time;
-    double result;
+    jsdouble day;
+    jsdouble msec_time;
+    jsdouble result;
 
     day = MakeDay(year, mon, mday);
     msec_time = MakeTime(hour, min, sec, msec);
     result = MakeDate(day, msec_time);
     return result;
 }
 
 /* compute the time in msec (unclipped) from the given args */
 #define MAXARGS        7
 
 static JSBool
 date_msecFromArgs(JSContext *cx, CallArgs args, double *rval)
 {
     uintN loop;
-    double array[MAXARGS];
-    double msec_time;
+    jsdouble array[MAXARGS];
+    jsdouble msec_time;
 
     for (loop = 0; loop < MAXARGS; loop++) {
         if (loop < args.length()) {
-            double d;
+            jsdouble d;
             if (!ToNumber(cx, args[loop], &d))
                 return JS_FALSE;
             /* return NaN if any arg is not finite */
             if (!JSDOUBLE_IS_FINITE(d)) {
                 *rval = js_NaN;
                 return JS_TRUE;
             }
             array[loop] = js_DoubleToInteger(d);
@@ -635,17 +635,17 @@ date_msecFromArgs(JSContext *cx, CallArg
 /*
  * See ECMA 15.9.4.[3-10];
  */
 static JSBool
 date_UTC(JSContext *cx, uintN argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
-    double msec_time;
+    jsdouble msec_time;
     if (!date_msecFromArgs(cx, args, &msec_time))
         return JS_FALSE;
 
     msec_time = TIMECLIP(msec_time);
 
     args.rval().setNumber(msec_time);
     return JS_TRUE;
 }
@@ -675,19 +675,19 @@ digits(size_t *result, const jschar *s, 
  * Read and convert decimal digits to the right of a decimal point,
  * representing a fractional integer, from s[*i] into *result
  * while *i < limit.
  *
  * Succeed if any digits are converted. Advance *i only
  * as digits are consumed.
  */
 static JSBool
-fractional(double *result, const jschar *s, size_t *i, size_t limit)
+fractional(jsdouble *result, const jschar *s, size_t *i, size_t limit)
 {
-    double factor = 0.1;
+    jsdouble factor = 0.1;
     size_t init = *i;
     *result = 0.0;
     while (*i < limit &&
            ('0' <= s[*i] && s[*i] <= '9')) {
         *result += (s[*i] - '0') * factor;
         factor *= 0.1;
         ++(*i);
     }
@@ -765,32 +765,32 @@ ndigits(size_t n, size_t *result, const 
  *   hh   = two digits of hour (00 through 23) (am/pm NOT allowed)
  *   mm   = two digits of minute (00 through 59)
  *   ss   = two digits of second (00 through 59)
  *   s    = one or more digits representing a decimal fraction of a second
  *   TZD  = time zone designator (Z or +hh:mm or -hh:mm or missing for local)
  */
 
 static JSBool
-date_parseISOString(JSLinearString *str, double *result, JSContext *cx)
+date_parseISOString(JSLinearString *str, jsdouble *result, JSContext *cx)
 {
-    double msec;
+    jsdouble msec;
 
     const jschar *s;
     size_t limit;
     size_t i = 0;
     int tzMul = 1;
     int dateMul = 1;
     size_t year = 1970;
     size_t month = 1;
     size_t day = 1;
     size_t hour = 0;
     size_t min = 0;
     size_t sec = 0;
-    double frac = 0;
+    jsdouble frac = 0;
     bool isLocalTime = JS_FALSE;
     size_t tzHour = 0;
     size_t tzMin = 0;
 
 #define PEEK(ch) (i < limit && s[i] == ch)
 
 #define NEED(ch)                                                     \
     JS_BEGIN_MACRO                                                   \
@@ -874,17 +874,17 @@ date_parseISOString(JSLinearString *str,
         || tzMin > 59)
         goto syntax;
 
     if (i != limit)
         goto syntax;
 
     month -= 1; /* convert month to 0-based */
 
-    msec = date_msecFromDate(dateMul * (double)year, month, day,
+    msec = date_msecFromDate(dateMul * (jsdouble)year, month, day,
                              hour, min, sec,
                              frac * 1000.0);;
 
     if (isLocalTime) {
         msec = UTC(msec, cx);
     } else {
         msec -= ((tzMul) * ((tzHour * msPerHour)
                             + (tzMin * msPerMinute)));
@@ -904,19 +904,19 @@ date_parseISOString(JSLinearString *str,
 
 #undef PEEK
 #undef NEED
 #undef DONE_UNLESS
 #undef NEED_NDIGITS
 }
 
 static JSBool
-date_parseString(JSLinearString *str, double *result, JSContext *cx)
+date_parseString(JSLinearString *str, jsdouble *result, JSContext *cx)
 {
-    double msec;
+    jsdouble msec;
 
     const jschar *s;
     size_t limit;
     size_t i = 0;
     int year = -1;
     int mon = -1;
     int mday = -1;
     int hour = -1;
@@ -1179,17 +1179,17 @@ syntax:
     *result = 0;
     return JS_FALSE;
 }
 
 static JSBool
 date_parse(JSContext *cx, uintN argc, Value *vp)
 {
     JSString *str;
-    double result;
+    jsdouble result;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return true;
     }
     str = ToString(cx, vp[2]);
     if (!str)
         return JS_FALSE;
@@ -1203,34 +1203,34 @@ date_parse(JSContext *cx, uintN argc, Va
         return true;
     }
 
     result = TIMECLIP(result);
     vp->setNumber(result);
     return true;
 }
 
-static inline double
+static inline jsdouble
 NowAsMillis()
 {
-    return (double) (PRMJ_Now() / PRMJ_USEC_PER_MSEC);
+    return (jsdouble) (PRMJ_Now() / PRMJ_USEC_PER_MSEC);
 }
 
 static JSBool
 date_now(JSContext *cx, uintN argc, Value *vp)
 {
     vp->setDouble(NowAsMillis());
     return JS_TRUE;
 }
 
 /*
  * Set UTC time to a given time and invalidate cached local time.
  */
 static JSBool
-SetUTCTime(JSContext *cx, JSObject *obj, double t, Value *vp = NULL)
+SetUTCTime(JSContext *cx, JSObject *obj, jsdouble t, Value *vp = NULL)
 {
     JS_ASSERT(obj->isDate());
 
     for (size_t ind = JSObject::JSSLOT_DATE_COMPONENTS_START;
          ind < JSObject::DATE_CLASS_RESERVED_SLOTS;
          ind++) {
         obj->setSlot(ind, UndefinedValue());
     }
@@ -1239,57 +1239,57 @@ SetUTCTime(JSContext *cx, JSObject *obj,
     if (vp)
         vp->setDouble(t);
     return true;
 }
 
 static void
 SetDateToNaN(JSContext *cx, JSObject *obj, Value *vp = NULL)
 {
-    double NaN = cx->runtime->NaNValue.getDoubleRef();
+    jsdouble NaN = cx->runtime->NaNValue.getDoubleRef();
     SetUTCTime(cx, obj, NaN, vp);
 }
 
 /*
  * Cache the local time, year, month, and so forth of the object.
  * If UTC time is not finite (e.g., NaN), the local time
  * slots will be set to the UTC time without conversion.
  */
 static bool
 FillLocalTimes(JSContext *cx, JSObject *obj)
 {
     JS_ASSERT(obj->isDate());
 
-    double utcTime = obj->getDateUTCTime().toNumber();
+    jsdouble utcTime = obj->getDateUTCTime().toNumber();
 
     if (!JSDOUBLE_IS_FINITE(utcTime)) {
         for (size_t ind = JSObject::JSSLOT_DATE_COMPONENTS_START;
              ind < JSObject::DATE_CLASS_RESERVED_SLOTS;
              ind++) {
             obj->setSlot(ind, DoubleValue(utcTime));
         }
         return true;
     }
 
-    double localTime = LocalTime(utcTime, cx);
+    jsdouble localTime = LocalTime(utcTime, cx);
 
     obj->setSlot(JSObject::JSSLOT_DATE_LOCAL_TIME, DoubleValue(localTime));
 
     jsint year = (jsint) floor(localTime /(msPerDay*365.2425)) + 1970;
-    double yearStartTime = (double) TimeFromYear(year);
+    jsdouble yearStartTime = (jsdouble) TimeFromYear(year);
 
     /* Adjust the year in case the approximation was wrong, as in YearFromTime. */
     jsint yearDays;
     if (yearStartTime > localTime) {
         year--;
         yearStartTime -= (msPerDay * DaysInYear(year));
         yearDays = DaysInYear(year);
     } else {
         yearDays = DaysInYear(year);
-        double nextStart = yearStartTime + (msPerDay * yearDays);
+        jsdouble nextStart = yearStartTime + (msPerDay * yearDays);
         if (nextStart <= localTime) {
             year++;
             yearStartTime = nextStart;
             yearDays = DaysInYear(year);
         }
     }
 
     obj->setSlot(JSObject::JSSLOT_DATE_LOCAL_YEAR, Int32Value(year));
@@ -1577,17 +1577,17 @@ date_getUTCDay(JSContext *cx, uintN argc
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     bool ok;
     JSObject *obj = NonGenericMethodGuard(cx, args, date_getUTCDay, &DateClass, &ok);
     if (!obj)
         return ok;
 
-    double result = obj->getDateUTCTime().toNumber();
+    jsdouble result = obj->getDateUTCTime().toNumber();
     if (JSDOUBLE_IS_FINITE(result))
         result = WeekDay(result);
 
     args.rval().setNumber(result);
     return true;
 }
 
 static JSBool
@@ -1735,17 +1735,17 @@ date_setTime(JSContext *cx, uintN argc, 
     if (!obj)
         return ok;
 
     if (args.length() == 0) {
         SetDateToNaN(cx, obj, &args.rval());
         return true;
     }
 
-    double result;
+    jsdouble result;
     if (!ToNumber(cx, args[0], &result))
         return false;
 
     return SetUTCTime(cx, obj, TIMECLIP(result), &args.rval());
 }
 
 static JSBool
 date_makeTime(JSContext *cx, Native native, uintN maxargs, JSBool local, uintN argc, Value *vp)
@@ -2039,44 +2039,44 @@ static const char* months[] =
 {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
 };
 
 
 // Avoid dependence on PRMJ_FormatTimeUSEnglish, because it
 // requires a PRMJTime... which only has 16-bit years.  Sub-ECMA.
 static void
-print_gmt_string(char* buf, size_t size, double utctime)
+print_gmt_string(char* buf, size_t size, jsdouble utctime)
 {
     JS_snprintf(buf, size, "%s, %.2d %s %.4d %.2d:%.2d:%.2d GMT",
                 days[WeekDay(utctime)],
                 DateFromTime(utctime),
                 months[MonthFromTime(utctime)],
                 YearFromTime(utctime),
                 HourFromTime(utctime),
                 MinFromTime(utctime),
                 SecFromTime(utctime));
 }
 
 static void
-print_iso_string(char* buf, size_t size, double utctime)
+print_iso_string(char* buf, size_t size, jsdouble utctime)
 {
     JS_snprintf(buf, size, "%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.3dZ",
                 YearFromTime(utctime),
                 MonthFromTime(utctime) + 1,
                 DateFromTime(utctime),
                 HourFromTime(utctime),
                 MinFromTime(utctime),
                 SecFromTime(utctime),
                 msFromTime(utctime));
 }
 
 static JSBool
 date_utc_format(JSContext *cx, Native native, CallArgs args,
-                void (*printFunc)(char*, size_t, double))
+                void (*printFunc)(char*, size_t, jsdouble))
 {
     bool ok;
     JSObject *obj = NonGenericMethodGuard(cx, args, native, &DateClass, &ok);
     if (!obj)
         return ok;
 
     double utctime = obj->getDateUTCTime().toNumber();
 
@@ -2155,17 +2155,17 @@ date_toJSON(JSContext *cx, uintN argc, V
         return false;
     *vp = args.rval();
     return true;
 }
 
 /* for Date.toLocaleString; interface to PRMJTime date struct.
  */
 static void
-new_explode(double timeval, PRMJTime *split, JSContext *cx)
+new_explode(jsdouble timeval, PRMJTime *split, JSContext *cx)
 {
     jsint year = YearFromTime(timeval);
 
     split->tm_usec = int32_t(msFromTime(timeval)) * 1000;
     split->tm_sec = int8_t(SecFromTime(timeval));
     split->tm_min = int8_t(MinFromTime(timeval));
     split->tm_hour = int8_t(HourFromTime(timeval));
     split->tm_mday = int8_t(DateFromTime(timeval));
@@ -2180,29 +2180,29 @@ new_explode(double timeval, PRMJTime *sp
 }
 
 typedef enum formatspec {
     FORMATSPEC_FULL, FORMATSPEC_DATE, FORMATSPEC_TIME
 } formatspec;
 
 /* helper function */
 static JSBool
-date_format(JSContext *cx, double date, formatspec format, CallReceiver call)
+date_format(JSContext *cx, jsdouble date, formatspec format, CallReceiver call)
 {
     char buf[100];
     JSString *str;
     char tzbuf[100];
     JSBool usetz;
     size_t i, tzlen;
     PRMJTime split;
 
     if (!JSDOUBLE_IS_FINITE(date)) {
         JS_snprintf(buf, sizeof buf, js_NaN_date_str);
     } else {
-        double local = LocalTime(date, cx);
+        jsdouble local = LocalTime(date, cx);
 
         /* offset from GMT in minutes.  The offset includes daylight savings,
            if it applies. */
         jsint minutes = (jsint) floor(AdjustTime(date, cx) / msPerMinute);
 
         /* map 510 minutes to 0830 hours */
         intN offset = (minutes / 60) * 100 + minutes % 60;
 
@@ -2302,17 +2302,17 @@ ToLocaleHelper(JSContext *cx, CallReceiv
 {
     double utctime = obj->getDateUTCTime().toNumber();
 
     char buf[100];
     if (!JSDOUBLE_IS_FINITE(utctime)) {
         JS_snprintf(buf, sizeof buf, js_NaN_date_str);
     } else {
         intN result_len;
-        double local = LocalTime(utctime, cx);
+        jsdouble local = LocalTime(utctime, cx);
         PRMJTime split;
         new_explode(local, &split, cx);
 
         /* let PRMJTime format it.       */
         result_len = PRMJ_FormatTime(buf, sizeof buf, format, &split);
 
         /* If it failed, default to toString. */
         if (result_len == 0)
@@ -2590,17 +2590,17 @@ js_Date(JSContext *cx, uintN argc, Value
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     /* Date called as function. */
     if (!IsConstructing(args))
         return date_format(cx, NowAsMillis(), FORMATSPEC_FULL, args);
 
     /* Date called as constructor. */
-    double d;
+    jsdouble d;
     if (args.length() == 0) {
         d = NowAsMillis();
     } else if (args.length() == 1) {
         if (!args[0].isString()) {
             /* the argument is a millisecond number */
             if (!ToNumber(cx, args[0], &d))
                 return false;
             d = TIMECLIP(d);
@@ -2615,17 +2615,17 @@ js_Date(JSContext *cx, uintN argc, Value
                 return false;
 
             if (!date_parseString(linearStr, &d, cx))
                 d = js_NaN;
             else
                 d = TIMECLIP(d);
         }
     } else {
-        double msec_time;
+        jsdouble msec_time;
         if (!date_msecFromArgs(cx, args, &msec_time))
             return false;
 
         if (JSDOUBLE_IS_FINITE(msec_time)) {
             msec_time = UTC(msec_time, cx);
             msec_time = TIMECLIP(msec_time);
         }
         d = msec_time;
@@ -2684,102 +2684,102 @@ js_InitDateClass(JSContext *cx, JSObject
 
     if (!DefineConstructorAndPrototype(cx, global, JSProto_Date, ctor, dateProto))
         return NULL;
 
     return dateProto;
 }
 
 JS_FRIEND_API(JSObject *)
-js_NewDateObjectMsec(JSContext *cx, double msec_time)
+js_NewDateObjectMsec(JSContext *cx, jsdouble msec_time)
 {
     JSObject *obj = NewBuiltinClassInstance(cx, &DateClass);
     if (!obj)
         return NULL;
     if (!SetUTCTime(cx, obj, msec_time))
         return NULL;
     return obj;
 }
 
 JS_FRIEND_API(JSObject *)
 js_NewDateObject(JSContext* cx, int year, int mon, int mday,
                  int hour, int min, int sec)
 {
     JSObject *obj;
-    double msec_time;
+    jsdouble msec_time;
 
     JS_ASSERT(mon < 12);
     msec_time = date_msecFromDate(year, mon, mday, hour, min, sec, 0);
     obj = js_NewDateObjectMsec(cx, UTC(msec_time, cx));
     return obj;
 }
 
 JS_FRIEND_API(JSBool)
 js_DateIsValid(JSContext *cx, JSObject* obj)
 {
     return obj->isDate() && !JSDOUBLE_IS_NaN(obj->getDateUTCTime().toNumber());
 }
 
 JS_FRIEND_API(int)
 js_DateGetYear(JSContext *cx, JSObject* obj)
 {
-    double localtime;
+    jsdouble localtime;
 
     /* Preserve legacy API behavior of returning 0 for invalid dates. */
     if (!GetAndCacheLocalTime(cx, obj, &localtime) ||
         JSDOUBLE_IS_NaN(localtime)) {
         return 0;
     }
 
     return (int) YearFromTime(localtime);
 }
 
 JS_FRIEND_API(int)
 js_DateGetMonth(JSContext *cx, JSObject* obj)
 {
-    double localtime;
+    jsdouble localtime;
 
     if (!GetAndCacheLocalTime(cx, obj, &localtime) ||
         JSDOUBLE_IS_NaN(localtime)) {
         return 0;
     }
 
     return (int) MonthFromTime(localtime);
 }
 
 JS_FRIEND_API(int)
 js_DateGetDate(JSContext *cx, JSObject* obj)
 {
-    double localtime;
+    jsdouble localtime;
 
     if (!GetAndCacheLocalTime(cx, obj, &localtime) ||
         JSDOUBLE_IS_NaN(localtime)) {
         return 0;
     }
 
     return (int) DateFromTime(localtime);
 }
 
 JS_FRIEND_API(int)
 js_DateGetHours(JSContext *cx, JSObject* obj)
 {
-    double localtime;
+    jsdouble localtime;
 
     if (!GetAndCacheLocalTime(cx, obj, &localtime) ||
         JSDOUBLE_IS_NaN(localtime)) {
         return 0;
     }
 
     return (int) HourFromTime(localtime);
 }
 
 JS_FRIEND_API(int)
 js_DateGetMinutes(JSContext *cx, JSObject* obj)
 {
-    double localtime;
+    jsdouble localtime;
 
     if (!GetAndCacheLocalTime(cx, obj, &localtime) ||
         JSDOUBLE_IS_NaN(localtime)) {
         return 0;
     }
 
     return (int) MinFromTime(localtime);
 }
@@ -2791,17 +2791,17 @@ js_DateGetSeconds(JSContext *cx, JSObjec
         return 0;
     
     double utctime = obj->getDateUTCTime().toNumber();
     if (JSDOUBLE_IS_NaN(utctime))
         return 0;
     return (int) SecFromTime(utctime);
 }
 
-JS_FRIEND_API(double)
+JS_FRIEND_API(jsdouble)
 js_DateGetMsecSinceEpoch(JSContext *cx, JSObject *obj)
 {
     return obj->isDate() ? obj->getDateUTCTime().toNumber() : 0;
 }
 
 #ifdef JS_THREADSAFE
 #include "prinrval.h"
 
--- a/js/src/jsdate.h
+++ b/js/src/jsdate.h
@@ -59,17 +59,17 @@ js_InitDateClass(JSContext *cx, JSObject
  * These functions provide a C interface to the date/time object
  */
 
 /*
  * Construct a new Date Object from a time value given in milliseconds UTC
  * since the epoch.
  */
 extern JS_FRIEND_API(JSObject*)
-js_NewDateObjectMsec(JSContext* cx, double msec_time);
+js_NewDateObjectMsec(JSContext* cx, jsdouble msec_time);
 
 /*
  * Construct a new Date Object from an exploded local time value.
  *
  * Assert that mon < 12 to help catch off-by-one user errors, which are common
  * due to the 0-based month numbering copied into JS from Java (java.util.Date
  * in 1995).
  */
--- a/js/src/jsinterp.cpp
+++ b/js/src/jsinterp.cpp
@@ -2362,17 +2362,17 @@ BEGIN_CASE(JSOP_BITNOT)
 }
 END_CASE(JSOP_BITNOT)
 
 BEGIN_CASE(JSOP_NEG)
 {
     /*
      * When the operand is int jsval, INT32_FITS_IN_JSVAL(i) implies
      * INT32_FITS_IN_JSVAL(-i) unless i is 0 or INT32_MIN when the
-     * results, -0.0 or INT32_MAX + 1, are double values.
+     * results, -0.0 or INT32_MAX + 1, are jsdouble values.
      */
     Value ref = regs.sp[-1];
     int32_t i;
     if (ref.isInt32() && (i = ref.toInt32()) != 0 && i != INT32_MIN) {
         i = -i;
         regs.sp[-1].setInt32(i);
     } else {
         double d;
--- a/js/src/jsmath.cpp
+++ b/js/src/jsmath.cpp
@@ -114,33 +114,33 @@ Class js::MathClass = {
     JS_EnumerateStub,
     JS_ResolveStub,
     JS_ConvertStub
 };
 
 JSBool
 js_math_abs(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     z = fabs(x);
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_acos(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
 #if defined(SOLARIS) && defined(__GNUC__)
@@ -155,17 +155,17 @@ math_acos(JSContext *cx, uintN argc, Val
     z = mathCache->lookup(acos, x);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_asin(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
 #if defined(SOLARIS) && defined(__GNUC__)
@@ -180,45 +180,45 @@ math_asin(JSContext *cx, uintN argc, Val
     z = mathCache->lookup(asin, x);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_atan(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
     if (!mathCache)
         return JS_FALSE;
     z = mathCache->lookup(atan, x);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
-static inline double JS_FASTCALL
-math_atan2_kernel(double x, double y)
+static inline jsdouble JS_FASTCALL
+math_atan2_kernel(jsdouble x, jsdouble y)
 {
 #if defined(_MSC_VER)
     /*
      * MSVC's atan2 does not yield the result demanded by ECMA when both x
      * and y are infinite.
      * - The result is a multiple of pi/4.
      * - The sign of x determines the sign of the result.
      * - The sign of y determines the multiplicator, 1 or 3.
      */
     if (JSDOUBLE_IS_INFINITE(x) && JSDOUBLE_IS_INFINITE(y)) {
-        double z = js_copysign(M_PI / 4, x);
+        jsdouble z = js_copysign(M_PI / 4, x);
         if (y < 0)
             z *= 3;
         return z;
     }
 #endif
 
 #if defined(SOLARIS) && defined(__GNUC__)
     if (x == 0) {
@@ -229,59 +229,59 @@ math_atan2_kernel(double x, double y)
     }
 #endif
     return atan2(x, y);
 }
 
 static JSBool
 math_atan2(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, y, z;
+    jsdouble x, y, z;
 
     if (argc <= 1) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x) || !ToNumber(cx, vp[3], &y))
         return JS_FALSE;
     z = math_atan2_kernel(x, y);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
-double
-js_math_ceil_impl(double x)
+jsdouble
+js_math_ceil_impl(jsdouble x)
 {
 #ifdef __APPLE__
     if (x < 0 && x > -1.0)
         return js_copysign(0, -1);
 #endif
     return ceil(x);
 }
 
 JSBool
 js_math_ceil(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     z = js_math_ceil_impl(x);
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_cos(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
@@ -304,58 +304,58 @@ math_exp_body(double d)
     }
 #endif
     return exp(d);
 }
 
 static JSBool
 math_exp(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
     if (!mathCache)
         return JS_FALSE;
     z = mathCache->lookup(math_exp_body, x);
     vp->setNumber(z);
     return JS_TRUE;
 }
 
-double
-js_math_floor_impl(double x)
+jsdouble
+js_math_floor_impl(jsdouble x)
 {
     return floor(x);
 }
 
 JSBool
 js_math_floor(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     z = js_math_floor_impl(x);
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_log(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
 #if defined(SOLARIS) && defined(__GNUC__)
@@ -370,17 +370,17 @@ math_log(JSContext *cx, uintN argc, Valu
     z = mathCache->lookup(log, x);
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 JSBool
 js_math_max(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z = js_NegativeInfinity;
+    jsdouble x, z = js_NegativeInfinity;
     Value *argv;
     uintN i;
 
     if (argc == 0) {
         vp->setDouble(js_NegativeInfinity);
         return JS_TRUE;
     }
     argv = vp + 2;
@@ -400,17 +400,17 @@ js_math_max(JSContext *cx, uintN argc, V
     }
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 JSBool
 js_math_min(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z = js_PositiveInfinity;
+    jsdouble x, z = js_PositiveInfinity;
     Value *argv;
     uintN i;
 
     if (argc == 0) {
         vp->setDouble(js_PositiveInfinity);
         return JS_TRUE;
     }
     argv = vp + 2;
@@ -427,48 +427,48 @@ js_math_min(JSContext *cx, uintN argc, V
         } else {
             z = (x < z) ? x : z;
         }
     }
     vp->setNumber(z);
     return JS_TRUE;
 }
 
-static double
-powi(double x, jsint y)
+static jsdouble
+powi(jsdouble x, jsint y)
 {
     jsuint n = (y < 0) ? -y : y;
-    double m = x;
-    double p = 1;
+    jsdouble m = x;
+    jsdouble p = 1;
     while (true) {
         if ((n & 1) != 0) p *= m;
         n >>= 1;
         if (n == 0) {
             if (y < 0) {
                 // Unfortunately, we have to be careful when p has reached
                 // infinity in the computation, because sometimes the higher
                 // internal precision in the pow() implementation would have
                 // given us a finite p. This happens very rarely.
                 
-                double result = 1.0 / p;
+                jsdouble result = 1.0 / p;
                 return (result == 0 && JSDOUBLE_IS_INFINITE(p))
-                       ? pow(x, static_cast<double>(y))  // Avoid pow(double, int).
+                       ? pow(x, static_cast<jsdouble>(y))  // Avoid pow(double, int).
                        : result;
             }
 
             return p;
         }
         m *= m;
     }
 }
 
 JSBool
 js_math_pow(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, y, z;
+    jsdouble x, y, z;
 
     if (argc <= 1) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x) || !ToNumber(cx, vp[3], &y))
         return JS_FALSE;
     /*
@@ -506,17 +506,17 @@ js_math_pow(JSContext *cx, uintN argc, V
 
     vp->setNumber(z);
     return JS_TRUE;
 }
 
 static const int64_t RNG_MULTIPLIER = 0x5DEECE66DLL;
 static const int64_t RNG_ADDEND = 0xBLL;
 static const int64_t RNG_MASK = (1LL << 48) - 1;
-static const double RNG_DSCALE = double(1LL << 53);
+static const jsdouble RNG_DSCALE = jsdouble(1LL << 53);
 
 /*
  * Math.random() support, lifted from java.util.Random.java.
  */
 extern void
 random_setSeed(int64_t *rngSeed, int64_t seed)
 {
     *rngSeed = (seed ^ RNG_MULTIPLIER) & RNG_MASK;
@@ -539,27 +539,27 @@ random_next(int64_t *rngSeed, int bits)
 {
     uint64_t nextseed = *rngSeed * RNG_MULTIPLIER;
     nextseed += RNG_ADDEND;
     nextseed &= RNG_MASK;
     *rngSeed = nextseed;
     return nextseed >> (48 - bits);
 }
 
-static inline double
+static inline jsdouble
 random_nextDouble(JSContext *cx)
 {
-    return double((random_next(&cx->rngSeed, 26) << 27) + random_next(&cx->rngSeed, 27)) /
+    return jsdouble((random_next(&cx->rngSeed, 26) << 27) + random_next(&cx->rngSeed, 27)) /
            RNG_DSCALE;
 }
 
 static JSBool
 math_random(JSContext *cx, uintN argc, Value *vp)
 {
-    double z = random_nextDouble(cx);
+    jsdouble z = random_nextDouble(cx);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
 #if defined _WIN32 && _MSC_VER < 1400
 /* Try to work around apparent _copysign bustage in VC7.x. */
 double
 js_copysign(double x, double y)
@@ -607,17 +607,17 @@ js_math_round(JSContext *cx, uintN argc,
 
     args.rval().setNumber(js_copysign(floor(x + 0.5), x));
     return true;
 }
 
 static JSBool
 math_sin(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
@@ -626,17 +626,17 @@ math_sin(JSContext *cx, uintN argc, Valu
     z = mathCache->lookup(sin, x);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
 JSBool
 js_math_sqrt(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
@@ -645,17 +645,17 @@ js_math_sqrt(JSContext *cx, uintN argc, 
     z = mathCache->lookup(sqrt, x);
     vp->setDouble(z);
     return JS_TRUE;
 }
 
 static JSBool
 math_tan(JSContext *cx, uintN argc, Value *vp)
 {
-    double x, z;
+    jsdouble x, z;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     MathCache *mathCache = GetMathCache(cx);
--- a/js/src/jsmath.h
+++ b/js/src/jsmath.h
@@ -110,15 +110,15 @@ extern JSBool
 js_math_round(JSContext *cx, uintN argc, js::Value *vp);
 
 extern JSBool
 js_math_sqrt(JSContext *cx, uintN argc, js::Value *vp);
 
 extern JSBool
 js_math_pow(JSContext *cx, uintN argc, js::Value *vp);
 
-extern double
-js_math_ceil_impl(double x);
+extern jsdouble
+js_math_ceil_impl(jsdouble x);
 
-extern double
-js_math_floor_impl(double x);
+extern jsdouble
+js_math_floor_impl(jsdouble x);
 
 #endif /* jsmath_h___ */
--- a/js/src/jsnum.cpp
+++ b/js/src/jsnum.cpp
@@ -88,17 +88,17 @@ using namespace js;
 using namespace js::types;
 
 /*
  * If we're accumulating a decimal number and the number is >= 2^53, then the
  * fast result from the loop in GetPrefixInteger may be inaccurate. Call
  * js_strtod_harder to get the correct answer.
  */
 static bool
-ComputeAccurateDecimalInteger(JSContext *cx, const jschar *start, const jschar *end, double *dp)
+ComputeAccurateDecimalInteger(JSContext *cx, const jschar *start, const jschar *end, jsdouble *dp)
 {
     size_t length = end - start;
     char *cstr = static_cast<char *>(cx->malloc_(length + 1));
     if (!cstr)
         return false;
 
     for (size_t i = 0; i < length; i++) {
         char c = char(start[i]);
@@ -162,42 +162,42 @@ class BinaryDigitReader
  * The fast result might also have been inaccurate for power-of-two bases. This
  * happens if the addition in value * 2 + digit causes a round-down to an even
  * least significant mantissa bit when the first dropped bit is a one.  If any
  * of the following digits in the number (which haven't been added in yet) are
  * nonzero, then the correct action would have been to round up instead of
  * down.  An example occurs when reading the number 0x1000000000000081, which
  * rounds to 0x1000000000000000 instead of 0x1000000000000100.
  */
-static double
+static jsdouble
 ComputeAccurateBinaryBaseInteger(JSContext *cx, const jschar *start, const jschar *end, int base)
 {
     BinaryDigitReader bdr(base, start, end);
 
     /* Skip leading zeroes. */
     int bit;
     do {
         bit = bdr.nextDigit();
     } while (bit == 0);
 
     JS_ASSERT(bit == 1); // guaranteed by GetPrefixInteger
 
     /* Gather the 53 significant bits (including the leading 1). */
-    double value = 1.0;
+    jsdouble value = 1.0;
     for (int j = 52; j > 0; j--) {
         bit = bdr.nextDigit();
         if (bit < 0)
             return value;
         value = value * 2 + bit;
     }
 
     /* bit2 is the 54th bit (the first dropped from the mantissa). */
     int bit2 = bdr.nextDigit();
     if (bit2 >= 0) {
-        double factor = 2.0;
+        jsdouble factor = 2.0;
         int sticky = 0;  /* sticky is 1 if any bit beyond the 54th is 1 */
         int bit3;
 
         while ((bit3 = bdr.nextDigit()) >= 0) {
             sticky |= bit3;
             factor *= 2;
         }
         value += bit2 & (bit | sticky);
@@ -206,23 +206,23 @@ ComputeAccurateBinaryBaseInteger(JSConte
 
     return value;
 }
 
 namespace js {
 
 bool
 GetPrefixInteger(JSContext *cx, const jschar *start, const jschar *end, int base,
-                 const jschar **endp, double *dp)
+                 const jschar **endp, jsdouble *dp)
 {
     JS_ASSERT(start <= end);
     JS_ASSERT(2 <= base && base <= 36);
 
     const jschar *s = start;
-    double d = 0.0;
+    jsdouble d = 0.0;
     for (; s < end; s++) {
         int digit;
         jschar c = *s;
         if ('0' <= c && c <= '9')
             digit = c - '0';
         else if ('a' <= c && c <= 'z')
             digit = c - 'a' + 10;
         else if ('A' <= c && c <= 'Z')
@@ -258,42 +258,42 @@ GetPrefixInteger(JSContext *cx, const js
 
 static JSBool
 num_isNaN(JSContext *cx, uintN argc, Value *vp)
 {
     if (argc == 0) {
         vp->setBoolean(true);
         return JS_TRUE;
     }
-    double x;
+    jsdouble x;
     if (!ToNumber(cx, vp[2], &x))
         return false;
     vp->setBoolean(JSDOUBLE_IS_NaN(x));
     return JS_TRUE;
 }
 
 static JSBool
 num_isFinite(JSContext *cx, uintN argc, Value *vp)
 {
     if (argc == 0) {
         vp->setBoolean(false);
         return JS_TRUE;
     }
-    double x;
+    jsdouble x;
     if (!ToNumber(cx, vp[2], &x))
         return JS_FALSE;
     vp->setBoolean(JSDOUBLE_IS_FINITE(x));
     return JS_TRUE;
 }
 
 static JSBool
 num_parseFloat(JSContext *cx, uintN argc, Value *vp)
 {
     JSString *str;
-    double d;
+    jsdouble d;
     const jschar *bp, *end, *ep;
 
     if (argc == 0) {
         vp->setDouble(js_NaN);
         return JS_TRUE;
     }
     str = ToString(cx, vp[2]);
     if (!str)
@@ -309,17 +309,17 @@ num_parseFloat(JSContext *cx, uintN argc
         return JS_TRUE;
     }
     vp->setNumber(d);
     return JS_TRUE;
 }
 
 static bool
 ParseIntStringHelper(JSContext *cx, const jschar *ws, const jschar *end, int maybeRadix,
-                     bool stripPrefix, double *dp)
+                     bool stripPrefix, jsdouble *dp)
 {
     JS_ASSERT(maybeRadix == 0 || (2 <= maybeRadix && maybeRadix <= 36));
     JS_ASSERT(ws <= end);
 
     const jschar *s = SkipSpace(ws, end);
     JS_ASSERT(ws <= s);
     JS_ASSERT(s <= end);
 
@@ -434,17 +434,17 @@ js::num_parseInt(JSContext *cx, uintN ar
     }
 
     /* Steps 2-5, 9-14. */
     const jschar *ws = inputString->getChars(cx);
     if (!ws)
         return false;
     const jschar *end = ws + inputString->length();
 
-    double number;
+    jsdouble number;
     if (!ParseIntStringHelper(cx, ws, end, radix, stripPrefix, &number))
         return false;
 
     /* Step 15. */
     args.rval().setNumber(number);
     return true;
 }
 
@@ -605,31 +605,31 @@ IntToCString(ToCStringBuf *cbuf, jsint i
     }
     if (i < 0)
         *--cp = '-';
 
     return cp.get();
 }
 
 static JSString * JS_FASTCALL
-js_NumberToStringWithBase(JSContext *cx, double d, jsint base);
+js_NumberToStringWithBase(JSContext *cx, jsdouble d, jsint base);
 
 static JS_ALWAYS_INLINE bool
 num_toStringHelper(JSContext *cx, Native native, uintN argc, Value *vp)
 {
     CallArgs args = CallArgsFromVp(argc, vp);
 
     double d;
     bool ok;
     if (!BoxedPrimitiveMethodGuard(cx, args, native, &d, &ok))
         return ok;
 
     int32_t base = 10;
     if (args.length() != 0 && !args[0].isUndefined()) {
-        double d2;
+        jsdouble d2;
         if (!ToInteger(cx, args[0], &d2))
             return false;
 
         if (d2 < 2 || d2 > 36) {
             JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL, JSMSG_BAD_RADIX);
             return false;
         }
 
@@ -888,19 +888,19 @@ static JSConstDoubleSpec number_constant
     {0,                         js_NaN_str,          0,{0,0,0}},
     {0,                         "POSITIVE_INFINITY", 0,{0,0,0}},
     {0,                         "NEGATIVE_INFINITY", 0,{0,0,0}},
     {1.7976931348623157E+308,   "MAX_VALUE",         0,{0,0,0}},
     {0,                         "MIN_VALUE",         0,{0,0,0}},
     {0,0,0,{0,0,0}}
 };
 
-double js_NaN;
-double js_PositiveInfinity;
-double js_NegativeInfinity;
+jsdouble js_NaN;
+jsdouble js_PositiveInfinity;
+jsdouble js_NegativeInfinity;
 
 #if (defined __GNUC__ && defined __i386__) || \
     (defined __SUNPRO_CC && defined __i386)
 
 /*
  * Set the exception mask to mask all exceptions and set the FPU precision
  * to 53 bit mantissa (64 bit doubles).
  */
@@ -1059,17 +1059,17 @@ namespace v8 {
 namespace internal {
 extern char* DoubleToCString(double v, char* buffer, int buflen);
 }
 }
 
 namespace js {
 
 static char *
-FracNumberToCString(JSContext *cx, ToCStringBuf *cbuf, double d, jsint base = 10)
+FracNumberToCString(JSContext *cx, ToCStringBuf *cbuf, jsdouble d, jsint base = 10)
 {
 #ifdef DEBUG
     {
         int32_t _;
         JS_ASSERT(!JSDOUBLE_IS_INT32(d, &_));
     }
 #endif
 
@@ -1091,28 +1091,28 @@ FracNumberToCString(JSContext *cx, ToCSt
                                DTOSTR_STANDARD, 0, d);
     } else {
         numStr = cbuf->dbuf = js_dtobasestr(cx->runtime->dtoaState, base, d);
     }
     return numStr;
 }
 
 char *
-NumberToCString(JSContext *cx, ToCStringBuf *cbuf, double d, jsint base/* = 10*/)
+NumberToCString(JSContext *cx, ToCStringBuf *cbuf, jsdouble d, jsint base/* = 10*/)
 {
     int32_t i;
     return (JSDOUBLE_IS_INT32(d, &i))
            ? IntToCString(cbuf, i, base)
            : FracNumberToCString(cx, cbuf, d, base);
 }
 
 }
 
 static JSString * JS_FASTCALL
-js_NumberToStringWithBase(JSContext *cx, double d, jsint base)
+js_NumberToStringWithBase(JSContext *cx, jsdouble d, jsint base)
 {
     ToCStringBuf cbuf;
     char *numStr;
 
     /*
      * Caller is responsible for error reporting. When called from trace,
      * returning NULL here will cause us to fall of trace and then retry
      * from the interpreter (which will report the error).
@@ -1155,25 +1155,25 @@ js_NumberToStringWithBase(JSContext *cx,
     }
 
     JSFixedString *s = js_NewStringCopyZ(cx, numStr);
     c->dtoaCache.cache(base, d, s);
     return s;
 }
 
 JSString * JS_FASTCALL
-js_NumberToString(JSContext *cx, double d)
+js_NumberToString(JSContext *cx, jsdouble d)
 {
     return js_NumberToStringWithBase(cx, d, 10);
 }
 
 namespace js {
 
 JSFixedString *
-NumberToString(JSContext *cx, double d)
+NumberToString(JSContext *cx, jsdouble d)
 {
     if (JSString *str = js_NumberToStringWithBase(cx, d, 10))
         return &str->asFixed();
     return NULL;
 }
 
 JSFixedString *
 IndexToString(JSContext *cx, uint32_t index)
@@ -1234,17 +1234,17 @@ ToNumberSlow(JSContext *cx, Value v, dou
     goto skip_int_double;
     for (;;) {
         if (v.isNumber()) {
             *out = v.toNumber();
             return true;
         }
       skip_int_double:
         if (v.isString())
-            return StringToNumberType<double>(cx, v.toString(), out);
+            return StringToNumberType<jsdouble>(cx, v.toString(), out);
         if (v.isBoolean()) {
             if (v.toBoolean()) {
                 *out = 1.0;
                 return true;
             }
             *out = 0.0;
             return true;
         }
@@ -1265,32 +1265,32 @@ ToNumberSlow(JSContext *cx, Value v, dou
     *out = js_NaN;
     return true;
 }
 
 bool
 ToInt32Slow(JSContext *cx, const Value &v, int32_t *out)
 {
     JS_ASSERT(!v.isInt32());
-    double d;
+    jsdouble d;
     if (v.isDouble()) {
         d = v.toDouble();
     } else {
         if (!ToNumberSlow(cx, v, &d))
             return false;
     }
     *out = js_DoubleToECMAInt32(d);
     return true;
 }
 
 bool
 ToUint32Slow(JSContext *cx, const Value &v, uint32_t *out)
 {
     JS_ASSERT(!v.isInt32());
-    double d;
+    jsdouble d;
     if (v.isDouble()) {
         d = v.toDouble();
     } else {
         if (!ToNumberSlow(cx, v, &d))
             return false;
     }
     *out = js_DoubleToECMAUint32(d);
     return true;
@@ -1299,17 +1299,17 @@ ToUint32Slow(JSContext *cx, const Value 
 }  /* namespace js */
 
 namespace js {
 
 bool
 NonstandardToInt32Slow(JSContext *cx, const Value &v, int32_t *out)
 {
     JS_ASSERT(!v.isInt32());
-    double d;
+    jsdouble d;
     if (v.isDouble()) {
         d = v.toDouble();
     } else if (!ToNumberSlow(cx, v, &d)) {
         return false;
     }
 
     if (JSDOUBLE_IS_NaN(d) || d <= -2147483649.0 || 2147483648.0 <= d) {
         js_ReportValueError(cx, JSMSG_CANT_CONVERT,
@@ -1319,30 +1319,30 @@ NonstandardToInt32Slow(JSContext *cx, co
     *out = (int32_t) floor(d + 0.5);  /* Round to nearest */
     return true;
 }
 
 bool
 ValueToUint16Slow(JSContext *cx, const Value &v, uint16_t *out)
 {
     JS_ASSERT(!v.isInt32());
-    double d;
+    jsdouble d;
     if (v.isDouble()) {
         d = v.toDouble();
     } else if (!ToNumberSlow(cx, v, &d)) {
         return false;
     }
 
     if (d == 0 || !JSDOUBLE_IS_FINITE(d)) {
         *out = 0;
         return true;
     }
 
     uint16_t u = (uint16_t) d;
-    if ((double)u == d) {
+    if ((jsdouble)u == d) {
         *out = u;
         return true;
     }
 
     bool neg = (d < 0);
     d = floor(neg ? -d : d);
     d = neg ? -d : d;
     jsuint m = JS_BIT(16);
@@ -1352,23 +1352,23 @@ ValueToUint16Slow(JSContext *cx, const V
     *out = (uint16_t) d;
     return true;
 }
 
 }  /* namespace js */
 
 JSBool
 js_strtod(JSContext *cx, const jschar *s, const jschar *send,
-          const jschar **ep, double *dp)
+          const jschar **ep, jsdouble *dp)
 {
     size_t i;
     char cbuf[32];
     char *cstr, *istr, *estr;
     JSBool negative;
-    double d;
+    jsdouble d;
 
     const jschar *s1 = SkipSpace(s, send);
     size_t length = send - s1;
 
     /* Use cbuf to avoid malloc */
     if (length >= sizeof cbuf) {
         cstr = (char *) cx->malloc_(length + 1);
         if (!cstr)
--- a/js/src/jsnum.h
+++ b/js/src/jsnum.h
@@ -78,64 +78,64 @@ typedef union jsdpun {
     struct {
 #if defined(IS_LITTLE_ENDIAN) && !defined(FPU_IS_ARM_FPA)
         uint32_t lo, hi;
 #else
         uint32_t hi, lo;
 #endif
     } s;
     uint64_t u64;
-    double d;
+    jsdouble d;
 } jsdpun;
 
 static inline int
-JSDOUBLE_IS_NaN(double d)
+JSDOUBLE_IS_NaN(jsdouble d)
 {
     jsdpun u;
     u.d = d;
     return (u.u64 & JSDOUBLE_EXPMASK) == JSDOUBLE_EXPMASK &&
            (u.u64 & JSDOUBLE_MANTMASK) != 0;
 }
 
 static inline int
-JSDOUBLE_IS_FINITE(double d)
+JSDOUBLE_IS_FINITE(jsdouble d)
 {
     /* -0 is finite. NaNs are not. */
     jsdpun u;
     u.d = d;
     return (u.u64 & JSDOUBLE_EXPMASK) != JSDOUBLE_EXPMASK;
 }
 
 static inline int
-JSDOUBLE_IS_INFINITE(double d)
+JSDOUBLE_IS_INFINITE(jsdouble d)
 {
     jsdpun u;
     u.d = d;
     return (u.u64 & ~JSDOUBLE_SIGNBIT) == JSDOUBLE_EXPMASK;
 }
 
 static inline bool
-JSDOUBLE_IS_NEG(double d)
+JSDOUBLE_IS_NEG(jsdouble d)
 {
     jsdpun u;
     u.d = d;
     return (u.s.hi & JSDOUBLE_HI32_SIGNBIT) != 0;
 }
 
 static inline uint32_t
-JS_HASH_DOUBLE(double d)
+JS_HASH_DOUBLE(jsdouble d)
 {
     jsdpun u;
     u.d = d;
     return u.s.lo ^ u.s.hi;
 }
 
-extern double js_NaN;
-extern double js_PositiveInfinity;
-extern double js_NegativeInfinity;
+extern jsdouble js_NaN;
+extern jsdouble js_PositiveInfinity;
+extern jsdouble js_NegativeInfinity;
 
 namespace js {
 
 extern bool
 InitRuntimeNumberState(JSRuntime *rt);
 
 extern void
 FinishRuntimeNumberState(JSRuntime *rt);
@@ -163,30 +163,30 @@ extern JSString * JS_FASTCALL
 js_IntToString(JSContext *cx, jsint i);
 
 /*
  * When base == 10, this function implements ToString() as specified by
  * ECMA-262-5 section 9.8.1; but note that it handles integers specially for
  * performance.  See also js::NumberToCString().
  */
 extern JSString * JS_FASTCALL
-js_NumberToString(JSContext *cx, double d);
+js_NumberToString(JSContext *cx, jsdouble d);
 
 namespace js {
 
 /*
  * Convert an integer or double (contained in the given value) to a string and
  * append to the given buffer.
  */
 extern bool JS_FASTCALL
 NumberValueToStringBuffer(JSContext *cx, const Value &v, StringBuffer &sb);
 
 /* Same as js_NumberToString, different signature. */
 extern JSFixedString *
-NumberToString(JSContext *cx, double d);
+NumberToString(JSContext *cx, jsdouble d);
 
 extern JSFixedString *
 IndexToString(JSContext *cx, uint32_t index);
 
 /*
  * Usually a small amount of static storage is enough, but sometimes we need
  * to dynamically allocate much more.  This struct encapsulates that.
  * Dynamically allocated memory will be freed when the object is destroyed.
@@ -208,17 +208,17 @@ struct ToCStringBuf
 
 /*
  * Convert a number to a C string.  When base==10, this function implements
  * ToString() as specified by ECMA-262-5 section 9.8.1.  It handles integral
  * values cheaply.  Return NULL if we ran out of memory.  See also
  * js_NumberToCString().
  */
 extern char *
-NumberToCString(JSContext *cx, ToCStringBuf *cbuf, double d, jsint base = 10);
+NumberToCString(JSContext *cx, ToCStringBuf *cbuf, jsdouble d, jsint base = 10);
 
 /*
  * The largest positive integer such that all positive integers less than it
  * may be precisely represented using the IEEE-754 double-precision format.
  */
 const double DOUBLE_INTEGRAL_PRECISION_LIMIT = uint64_t(1) << 53;
 
 /*
@@ -230,17 +230,17 @@ const double DOUBLE_INTEGRAL_PRECISION_L
  * base is 10 or a power of two the returned integer is the closest possible
  * double; otherwise extremely large integers may be slightly inaccurate.
  *
  * If [start, end) does not begin with a number with the specified base,
  * *dp == 0 and *endp == start upon return.
  */
 extern bool
 GetPrefixInteger(JSContext *cx, const jschar *start, const jschar *end, int base,
-                 const jschar **endp, double *dp);
+                 const jschar **endp, jsdouble *dp);
 
 /* ES5 9.3 ToNumber. */
 JS_ALWAYS_INLINE bool
 ToNumber(JSContext *cx, const Value &v, double *out)
 {
     if (v.isNumber()) {
         *out = v.toNumber();
         return true;
@@ -336,17 +336,17 @@ num_parseInt(JSContext *cx, uintN argc, 
  *  3.  Compute sign(Result(1)) * floor(abs(Result(1))).
  *  4.  Compute Result(3) modulo 2^32; that is, a finite integer value k of Number
  *      type with positive sign and less than 2^32 in magnitude such the mathematical
  *      difference of Result(3) and k is mathematically an integer multiple of 2^32.
  *  5.  If Result(4) is greater than or equal to 2^31, return Result(4)- 2^32,
  *  otherwise return Result(4).
  */
 static inline int32_t
-js_DoubleToECMAInt32(double d)
+js_DoubleToECMAInt32(jsdouble d)
 {
 #if defined(__i386__) || defined(__i386) || defined(__x86_64__) || \
     defined(_M_IX86) || defined(_M_X64)
     jsdpun du, duh, two32;
     uint32_t di_h, u_tmp, expon, shift_amount;
     int32_t mask32;
 
     /*
@@ -534,45 +534,45 @@ js_DoubleToECMAInt32(double d)
 "9:\n"
     : "=r" (i), "=&r" (tmp0), "=&r" (tmp1), "=&r" (tmp2)
     : "r" (d)
     : "cc"
         );
     return i;
 #else
     int32_t i;
-    double two32, two31;
+    jsdouble two32, two31;
 
     if (!JSDOUBLE_IS_FINITE(d))
         return 0;
 
     i = (int32_t) d;
-    if ((double) i == d)
+    if ((jsdouble) i == d)
         return i;
 
     two32 = 4294967296.0;
     two31 = 2147483648.0;
     d = fmod(d, two32);
     d = (d >= 0) ? floor(d) : ceil(d) + two32;
     return (int32_t) (d >= two31 ? d - two32 : d);
 #endif
 }
 
 inline uint32_t
-js_DoubleToECMAUint32(double d)
+js_DoubleToECMAUint32(jsdouble d)
 {
     return uint32_t(js_DoubleToECMAInt32(d));
 }
 
 /*
- * Convert a double to an integral number, stored in a double.
+ * Convert a jsdouble to an integral number, stored in a jsdouble.
  * If d is NaN, return 0.  If d is an infinity, return it without conversion.
  */
-static inline double
-js_DoubleToInteger(double d)
+static inline jsdouble
+js_DoubleToInteger(jsdouble d)
 {
     if (d == 0)
         return d;
 
     if (!JSDOUBLE_IS_FINITE(d)) {
         if (JSDOUBLE_IS_NaN(d))
             return 0;
         return d;
@@ -591,17 +591,17 @@ js_DoubleToInteger(double d)
  *
  * Also allows inputs of the form [+|-]Infinity, which produce an infinity of
  * the appropriate sign.  The case of the "Infinity" string must match exactly.
  * If the string does not contain a number, set *ep to s and return 0.0 in dp.
  * Return false if out of memory.
  */
 extern JSBool
 js_strtod(JSContext *cx, const jschar *s, const jschar *send,
-          const jschar **ep, double *dp);
+          const jschar **ep, jsdouble *dp);
 
 extern JSBool
 js_num_valueOf(JSContext *cx, uintN argc, js::Value *vp);
 
 namespace js {
 
 static JS_ALWAYS_INLINE bool
 ValueFitsInInt32(const Value &v, int32_t *pi)
@@ -636,17 +636,17 @@ IsDefinitelyIndex(const Value &v, uint32
         return true;
     }
 
     return false;
 }
 
 /* ES5 9.4 ToInteger. */
 static inline bool
-ToInteger(JSContext *cx, const js::Value &v, double *dp)
+ToInteger(JSContext *cx, const js::Value &v, jsdouble *dp)
 {
     if (v.isInt32()) {
         *dp = v.toInt32();
         return true;
     }
     if (v.isDouble()) {
         *dp = v.toDouble();
     } else {
--- a/js/src/jsnuminlines.h
+++ b/js/src/jsnuminlines.h
@@ -46,22 +46,22 @@
 
 
 namespace js {
 
 template<typename T> struct NumberTraits { };
 template<> struct NumberTraits<int32_t> {
   static JS_ALWAYS_INLINE int32_t NaN() { return 0; }
   static JS_ALWAYS_INLINE int32_t toSelfType(int32_t i) { return i; }
-  static JS_ALWAYS_INLINE int32_t toSelfType(double d) { return js_DoubleToECMAUint32(d); }
+  static JS_ALWAYS_INLINE int32_t toSelfType(jsdouble d) { return js_DoubleToECMAUint32(d); }
 };
-template<> struct NumberTraits<double> {
-  static JS_ALWAYS_INLINE double NaN() { return js_NaN; }
-  static JS_ALWAYS_INLINE double toSelfType(int32_t i) { return i; }
-  static JS_ALWAYS_INLINE double toSelfType(double d) { return d; }
+template<> struct NumberTraits<jsdouble> {
+  static JS_ALWAYS_INLINE jsdouble NaN() { return js_NaN; }
+  static JS_ALWAYS_INLINE jsdouble toSelfType(int32_t i) { return i; }
+  static JS_ALWAYS_INLINE jsdouble toSelfType(jsdouble d) { return d; }
 };
 
 template<typename T>
 static JS_ALWAYS_INLINE bool
 StringToNumberType(JSContext *cx, JSString *str, T *result)
 {
     size_t length = str->length();
     const jschar *chars = str->getChars(NULL);
--- a/js/src/json.cpp
+++ b/js/src/json.cpp
@@ -704,33 +704,33 @@ js_Stringify(JSContext *cx, Value *vp, J
             replacer = NULL;
         }
     }
 
     /* Step 5. */
     if (space.isObject()) {
         JSObject &spaceObj = space.toObject();
         if (ObjectClassIs(spaceObj, ESClass_Number, cx)) {
-            double d;
+            jsdouble d;
             if (!ToNumber(cx, space, &d))
                 return false;
             space = NumberValue(d);
         } else if (ObjectClassIs(spaceObj, ESClass_String, cx)) {
             JSString *str = ToStringSlow(cx, space);
             if (!str)
                 return false;
             space = StringValue(str);
         }
     }
 
     StringBuffer gap(cx);
 
     if (space.isNumber()) {
         /* Step 6. */
-        double d;
+        jsdouble d;
         JS_ALWAYS_TRUE(ToInteger(cx, space, &d));
         d = JS_MIN(10, d);
         if (d >= 1 && !gap.appendN(' ', uint32_t(d)))
             return false;
     } else if (space.isString()) {
         /* Step 7. */
         JSLinearString *str = space.toString()->ensureLinear(cx);
         if (!str)
--- a/js/src/jsonparser.cpp
+++ b/js/src/jsonparser.cpp
@@ -212,17 +212,17 @@ JSONParser::readNumber()
             if (!JS7_ISDEC(*current))
                 break;
         }
     }
 
     /* Fast path: no fractional or exponent part. */
     if (current == end || (*current != '.' && *current != 'e' && *current != 'E')) {
         const jschar *dummy;
-        double d;
+        jsdouble d;
         if (!GetPrefixInteger(cx, digitStart.get(), current.get(), 10, &dummy, &d))
             return token(OOM);
         JS_ASSERT(current == dummy);
         return numberToken(negative ? -d : d);
     }
 
     /* (\.[0-9]+)? */
     if (current < end && *current == '.') {
@@ -257,17 +257,17 @@ JSONParser::readNumber()
             return token(Error);
         }
         while (++current < end) {
             if (!JS7_ISDEC(*current))
                 break;
         }
     }
 
-    double d;
+    jsdouble d;
     const jschar *finish;
     if (!js_strtod(cx, digitStart.get(), current.get(), &finish, &d))
         return token(OOM);
     JS_ASSERT(current == finish);
     return numberToken(negative ? -d : d);
 }
 
 static inline bool
--- a/js/src/jsonparser.h
+++ b/js/src/jsonparser.h
@@ -147,17 +147,17 @@ class JSONParser
     Token stringToken(JSString *str) {
         this->v = js::StringValue(str);
 #ifdef DEBUG
         lastToken = String;
 #endif
         return String;
     }
 
-    Token numberToken(double d) {
+    Token numberToken(jsdouble d) {
         this->v = js::NumberValue(d);
 #ifdef DEBUG
         lastToken = Number;
 #endif
         return Number;
     }
 
     enum StringType { PropertyName, LiteralValue };
--- a/js/src/jsopcode.cpp
+++ b/js/src/jsopcode.cpp
@@ -1593,17 +1593,17 @@ CompareTableEntries(const TableEntry &a,
 {
     *lessOrEqualp = (a.offset != b.offset) ? a.offset <= b.offset : a.order <= b.order;
     return true;
 }
 
 static ptrdiff_t
 SprintDoubleValue(Sprinter *sp, jsval v, JSOp *opp)
 {
-    double d;
+    jsdouble d;
     ptrdiff_t todo;
     char *s;
 
     JS_ASSERT(JSVAL_IS_DOUBLE(v));
     d = JSVAL_TO_DOUBLE(v);
     if (JSDOUBLE_IS_NEGZERO(d)) {
         todo = sp->put("-0");
         *opp = JSOP_NEG;
--- a/js/src/jspubtd.h
+++ b/js/src/jspubtd.h
@@ -92,16 +92,17 @@ typedef ptrdiff_t jsid;
 # define JSID_BITS(id) (id)
 #endif
 
 JS_BEGIN_EXTERN_C
 
 /* Scalar typedefs. */
 typedef int32_t   jsint;
 typedef uint32_t  jsuint;
+typedef double    jsdouble;
 typedef int32_t   jsrefcount;   /* PRInt32 if JS_THREADSAFE, see jslock.h */
 
 #ifdef WIN32
 typedef wchar_t   jschar;
 #else
 typedef uint16_t  jschar;
 #endif
 
--- a/js/src/jsscript.cpp
+++ b/js/src/jsscript.cpp
@@ -1060,17 +1060,17 @@ JSScript::NewScript(JSContext *cx, uint3
                          offsetof(JSScript, inlineData) % sizeof(Value) == 0);
     } else
 #endif
     {
         /*
          * We assume that calloc aligns on sizeof(Value) if the size we ask to
          * allocate divides sizeof(Value).
          */
-        JS_STATIC_ASSERT(sizeof(Value) == sizeof(double));
+        JS_STATIC_ASSERT(sizeof(Value) == sizeof(jsdouble));
         data = static_cast<uint8_t *>(cx->calloc_(JS_ROUNDUP(size, sizeof(Value))));
         if (!data)
             return NULL;
     }
 
     JSScript *script = js_NewGCScript(cx);
     if (!script) {
         Foreground::free_(data);
--- a/js/src/jsstr.cpp
+++ b/js/src/jsstr.cpp
@@ -1173,17 +1173,17 @@ str_indexOf(JSContext *cx, uintN argc, V
                 start = textlen;
                 textlen = 0;
             } else {
                 start = i;
                 text += start;
                 textlen -= start;
             }
         } else {
-            double d;
+            jsdouble d;
             if (!ToInteger(cx, args[1], &d))
                 return false;
             if (d <= 0) {
                 start = 0;
             } else if (d > textlen) {
                 start = textlen;
                 textlen = 0;
             } else {
@@ -2551,17 +2551,17 @@ js::str_split(JSContext *cx, uintN argc,
     TypeObject *type = GetTypeCallerInitObject(cx, JSProto_Array);
     if (!type)
         return false;
     AddTypeProperty(cx, type, NULL, Type::StringType());
 
     /* Step 5: Use the second argument as the split limit, if given. */
     uint32_t limit;
     if (args.length() > 1 && !args[1].isUndefined()) {
-        double d;
+        jsdouble d;
         if (!ToNumber(cx, args[1], &d))
             return false;
         limit = js_DoubleToECMAUint32(d);
     } else {
         limit = UINT32_MAX;
     }
 
     /* Step 8. */
--- a/js/src/jstypedarray.cpp
+++ b/js/src/jstypedarray.cpp
@@ -88,22 +88,22 @@ ValueIsLength(JSContext *cx, const Value
         int32_t i = v.toInt32();
         if (i < 0)
             return false;
         *len = i;
         return true;
     }
 
     if (v.isDouble()) {
-        double d = v.toDouble();
+        jsdouble d = v.toDouble();
         if (JSDOUBLE_IS_NaN(d))
             return false;
 
         jsuint length = jsuint(d);
-        if (d != double(length))
+        if (d != jsdouble(length))
             return false;
 
         *len = length;
         return true;
     }
 
     return false;
 }
@@ -946,17 +946,17 @@ js_TypedArray_uint8_clamp_double(const d
 {
     // Not < so that NaN coerces to 0
     if (!(x >= 0))
         return 0;
 
     if (x > 255)
         return 255;
 
-    double toTruncate = x + 0.5;
+    jsdouble toTruncate = x + 0.5;
     uint8_t y = uint8_t(toTruncate);
 
     /*
      * now val is rounded to nearest, ties rounded up.  We want
      * rounded to nearest ties to even, so check whether we had a
      * tie.
      */
     if (y == toTruncate) {
@@ -982,17 +982,17 @@ struct uint8_clamped {
 
     // invoke our assignment helpers for constructor conversion
     uint8_clamped(uint8_t x)    { *this = x; }
     uint8_clamped(uint16_t x)   { *this = x; }
     uint8_clamped(uint32_t x)   { *this = x; }
     uint8_clamped(int8_t x)     { *this = x; }
     uint8_clamped(int16_t x)    { *this = x; }
     uint8_clamped(int32_t x)    { *this = x; }
-    uint8_clamped(double x)     { *this = x; }
+    uint8_clamped(jsdouble x) { *this = x; }
 
     inline uint8_clamped& operator= (const uint8_clamped& x) {
         val = x.val;
         return *this;
     }
 
     inline uint8_clamped& operator= (uint8_t x) {
         val = x;
@@ -1027,17 +1027,17 @@ struct uint8_clamped {
         val = (x >= 0)
               ? ((x < 255)
                  ? uint8_t(x)
                  : 255)
               : 0;
         return *this;
     }
 
-    inline uint8_clamped& operator= (const double x) {
+    inline uint8_clamped& operator= (const jsdouble x) {
         val = uint8_t(js_TypedArray_uint8_clamp_double(x));
         return *this;
     }
 
     inline operator uint8_t() const {
         return val;
     }
 };
@@ -1204,17 +1204,17 @@ class TypedArrayTemplate
         JS_ASSERT(tarray);
         JS_ASSERT(index < getLength(tarray));
 
         if (vp->isInt32()) {
             setIndex(tarray, index, NativeType(vp->toInt32()));
             return true;
         }
 
-        double d;
+        jsdouble d;
         if (vp->isDouble()) {
             d = vp->toDouble();
         } else if (vp->isNull()) {
             d = 0.0;
         } else if (vp->isPrimitive()) {
             JS_ASSERT(vp->isString() || vp->isUndefined() || vp->isBoolean());
             if (vp->isString()) {
                 JS_ALWAYS_TRUE(ToNumber(cx, *vp, &d));
@@ -1806,17 +1806,17 @@ class TypedArrayTemplate
         if (v.isDouble())
             return nativeFromDouble(v.toDouble());
 
         /*
          * The condition guarantees that holes and undefined values
          * are treated identically.
          */
         if (v.isPrimitive() && !v.isMagic() && !v.isUndefined()) {
-            double dval;
+            jsdouble dval;
             JS_ALWAYS_TRUE(ToNumber(cx, v, &dval));
             return nativeFromDouble(dval);
         }
 
         return ArrayTypeIsFloatingPoint()
                ? NativeType(js_NaN)
                : NativeType(int32_t(0));
     }
--- a/js/src/jsxdrapi.cpp
+++ b/js/src/jsxdrapi.cpp
@@ -468,17 +468,17 @@ JS_XDRStringOrNull(JSXDRState *xdr, JSSt
     if (null) {
         *strp = NULL;
         return JS_TRUE;
     }
     return JS_XDRString(xdr, strp);
 }
 
 JS_PUBLIC_API(JSBool)
-JS_XDRDouble(JSXDRState *xdr, double *dp)
+JS_XDRDouble(JSXDRState *xdr, jsdouble *dp)
 {
     jsdpun u;
 
     u.d = (xdr->mode == JSXDR_ENCODE) ? *dp : 0.0;
     if (!JS_XDRUint32(xdr, &u.s.lo) || !JS_XDRUint32(xdr, &u.s.hi))
         return false;
     if (xdr->mode == JSXDR_DECODE)
         *dp = u.d;
--- a/js/src/jsxdrapi.h
+++ b/js/src/jsxdrapi.h
@@ -153,17 +153,17 @@ JS_XDRCString(JSXDRState *xdr, char **sp
 
 extern JS_PUBLIC_API(JSBool)
 JS_XDRString(JSXDRState *xdr, JSString **strp);
 
 extern JS_PUBLIC_API(JSBool)
 JS_XDRStringOrNull(JSXDRState *xdr, JSString **strp);
 
 extern JS_PUBLIC_API(JSBool)
-JS_XDRDouble(JSXDRState *xdr, double *dp);
+JS_XDRDouble(JSXDRState *xdr, jsdouble *dp);
 
 extern JS_PUBLIC_API(JSBool)
 JS_XDRFunctionObject(JSXDRState *xdr, JSObject **objp);
 
 extern JS_PUBLIC_API(JSBool)
 JS_XDRScript(JSXDRState *xdr, JSScript **scriptp);
 
 /*
--- a/js/src/jsxml.cpp
+++ b/js/src/jsxml.cpp
@@ -5237,17 +5237,17 @@ js_GetXMLMethod(JSContext *cx, JSObject 
 
 JSBool
 js_TestXMLEquality(JSContext *cx, const Value &v1, const Value &v2, JSBool *bp)
 {
     JSXML *xml, *vxml;
     JSObject *vobj;
     JSBool ok;
     JSString *str, *vstr;
-    double d, d2;
+    jsdouble d, d2;
 
     JSObject *obj;
     jsval v;
     if (v1.isObject() && v1.toObject().isXML()) {
         obj = &v1.toObject();
         v = v2;
     } else {
         v = v1;
--- a/js/src/methodjit/TypedArrayIC.h
+++ b/js/src/methodjit/TypedArrayIC.h
@@ -77,20 +77,20 @@ ConstantFoldForFloatArray(JSContext *cx,
     }
 
     if (!vr->isConstant())
         return true;
 
     if (vr->knownType() == JSVAL_TYPE_DOUBLE)
         return true;
 
-    double d = 0;
+    jsdouble d = 0;
     Value v = vr->value();
     if (v.isString()) {
-        if (!StringToNumberType<double>(cx, v.toString(), &d))
+        if (!StringToNumberType<jsdouble>(cx, v.toString(), &d))
             return false;
     } else if (v.isBoolean()) {
         d = v.toBoolean() ? 1 : 0;
     } else if (v.isInt32()) {
         d = v.toInt32();
     } else {
         JS_NOT_REACHED("unknown constant type");
     }
--- a/js/src/perf/jsperf.cpp
+++ b/js/src/perf/jsperf.cpp
@@ -86,17 +86,17 @@ pm_finalize(JSContext* cx, JSObject* obj
 
 #define GETTER(name)                                                    \
     static JSBool                                                       \
     pm_get_##name(JSContext* cx, JSObject* obj, jsid /*unused*/, jsval* vp) \
     {                                                                   \
         PerfMeasurement* p = GetPM(cx, obj, #name);                     \
         if (!p)                                                         \
             return JS_FALSE;                                            \
-        return JS_NewNumberValue(cx, double(p->name), vp);              \
+        return JS_NewNumberValue(cx, jsdouble(p->name), vp);            \
     }
 
 GETTER(cpu_cycles)
 GETTER(instructions)
 GETTER(cache_references)
 GETTER(cache_misses)
 GETTER(branch_instructions)
 GETTER(branch_misses)
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -145,37 +145,37 @@ static PRUintn gStackBaseThreadIndex;
 #else
 static uintptr_t gStackBase;
 #endif
 
 /*
  * Limit the timeout to 30 minutes to prevent an overflow on platfoms
  * that represent the time internally in microseconds using 32-bit int.
  */
-static double MAX_TIMEOUT_INTERVAL = 1800.0;
-static double gTimeoutInterval = -1.0;
+static jsdouble MAX_TIMEOUT_INTERVAL = 1800.0;
+static jsdouble gTimeoutInterval = -1.0;
 static volatile bool gCanceled = false;
 
 static bool enableMethodJit = false;
 static bool enableTypeInference = false;
 static bool enableDisassemblyDumps = false;
 
 static bool printTiming = false;
 
 static JSBool
-SetTimeoutValue(JSContext *cx, double t);
+SetTimeoutValue(JSContext *cx, jsdouble t);
 
 static bool
 InitWatchdog(JSRuntime *rt);
 
 static void
 KillWatchdog();
 
 static bool
-ScheduleWatchdog(JSRuntime *rt, double t);
+ScheduleWatchdog(JSRuntime *rt, jsdouble t);
 
 static void
 CancelExecution(JSRuntime *rt);
 
 /*
  * Watchdog thread state.
  */
 #ifdef JS_THREADSAFE
@@ -678,17 +678,17 @@ Version(JSContext *cx, uintN argc, jsval
         /* Get version. */
         *vp = INT_TO_JSVAL(JS_GetVersion(cx));
     } else {
         /* Set version. */
         int32_t v = -1;
         if (JSVAL_IS_INT(argv[0])) {
             v = JSVAL_TO_INT(argv[0]);
         } else if (JSVAL_IS_DOUBLE(argv[0])) {
-            double fv = JSVAL_TO_DOUBLE(argv[0]);
+            jsdouble fv = JSVAL_TO_DOUBLE(argv[0]);
             if (int32_t(fv) == fv)
                 v = int32_t(fv);
         }
         if (v < 0 || v > JSVERSION_LATEST) {
             JS_ReportErrorNumber(cx, my_GetErrorMessage, NULL, JSSMSG_INVALID_ARGS, "version");
             return false;
         }
         *vp = INT_TO_JSVAL(JS_SetVersion(cx, JSVersion(v)));
@@ -1108,17 +1108,17 @@ PutStr(JSContext *cx, uintN argc, jsval 
 
     JS_SET_RVAL(cx, vp, JSVAL_VOID);
     return JS_TRUE;
 }
 
 static JSBool
 Now(JSContext *cx, uintN argc, jsval *vp)
 {
-    double now = PRMJ_Now() / double(PRMJ_USEC_PER_MSEC);
+    jsdouble now = PRMJ_Now() / double(PRMJ_USEC_PER_MSEC);
     JS_SET_RVAL(cx, vp, DOUBLE_TO_JSVAL(now));
     return true;
 }
 
 static JSBool
 PrintInternal(JSContext *cx, uintN argc, jsval *vp, FILE *file)
 {
     jsval *argv;
@@ -1608,17 +1608,17 @@ CountHeap(JSContext *cx, uintN argc, jsv
         JS_TraceChildren(&countTracer.base, node->thing, node->kind);
     }
     while ((node = countTracer.recycleList) != NULL) {
         countTracer.recycleList = node->next;
         js_free(node);
     }
     JS_DHashTableFinish(&countTracer.visited);
 
-    return countTracer.ok && JS_NewNumberValue(cx, (double) counter, vp);
+    return countTracer.ok && JS_NewNumberValue(cx, (jsdouble) counter, vp);
 }
 
 static jsrefcount finalizeCount = 0;
 
 static void
 finalize_counter_finalize(JSContext *cx, JSObject *obj)
 {
     JS_ATOMIC_INCREMENT(&finalizeCount);
@@ -2654,31 +2654,31 @@ EscapeWideString(jschar *w)
 #include <stdarg.h>
 
 static JSBool
 ZZ_formatter(JSContext *cx, const char *format, JSBool fromJS, jsval **vpp,
              va_list *app)
 {
     jsval *vp;
     va_list ap;
-    double re, im;
+    jsdouble re, im;
 
     printf("entering ZZ_formatter");
     vp = *vpp;
     ap = *app;
     if (fromJS) {
         if (!JS_ValueToNumber(cx, vp[0], &re))
             return JS_FALSE;
         if (!JS_ValueToNumber(cx, vp[1], &im))
             return JS_FALSE;
-        *va_arg(ap, double *) = re;
-        *va_arg(ap, double *) = im;
+        *va_arg(ap, jsdouble *) = re;
+        *va_arg(ap, jsdouble *) = im;
     } else {
-        re = va_arg(ap, double);
-        im = va_arg(ap, double);
+        re = va_arg(ap, jsdouble);
+        im = va_arg(ap, jsdouble);
         if (!JS_NewNumberValue(cx, re, &vp[0]))
             return JS_FALSE;
         if (!JS_NewNumberValue(cx, im, &vp[1]))
             return JS_FALSE;
     }
     *vpp = vp + 2;
     *app = ap;
     printf("leaving ZZ_formatter");
@@ -2687,17 +2687,17 @@ ZZ_formatter(JSContext *cx, const char *
 
 static JSBool
 ConvertArgs(JSContext *cx, uintN argc, jsval *vp)
 {
     JSBool b = JS_FALSE;
     jschar c = 0;
     int32_t i = 0, j = 0;
     uint32_t u = 0;
-    double d = 0, I = 0, re = 0, im = 0;
+    jsdouble d = 0, I = 0, re = 0, im = 0;
     JSString *str = NULL;
     jschar *w = NULL;
     JSObject *obj2 = NULL;
     JSFunction *fun = NULL;
     jsval v = JSVAL_VOID;
     JSBool ok;
 
     if (!JS_AddArgumentFormatter(cx, "ZZ", ZZ_formatter))
@@ -3313,17 +3313,17 @@ IsBefore(PRIntervalTime t1, PRIntervalTi
 static JSBool
 Sleep_fn(JSContext *cx, uintN argc, jsval *vp)
 {
     PRIntervalTime t_ticks;
 
     if (argc == 0) {
         t_ticks = 0;
     } else {
-        double t_secs;
+        jsdouble t_secs;
 
         if (!JS_ValueToNumber(cx, argc == 0 ? JSVAL_VOID : vp[2], &t_secs))
             return JS_FALSE;
 
         /* NB: The next condition also filter out NaNs. */
         if (!(t_secs <= MAX_TIMEOUT_INTERVAL)) {
             JS_ReportError(cx, "Excessive sleep interval");
             return JS_FALSE;
@@ -3421,17 +3421,17 @@ WatchdogMain(void *arg)
                 PR_WaitCondVar(gWatchdogWakeup, sleepDuration);
             JS_ASSERT(status == PR_SUCCESS);
         }
     }
     PR_Unlock(gWatchdogLock);
 }
 
 static bool
-ScheduleWatchdog(JSRuntime *rt, double t)
+ScheduleWatchdog(JSRuntime *rt, jsdouble t)
 {
     if (t <= 0) {
         PR_Lock(gWatchdogLock);
         gWatchdogHasTimeout = false;
         PR_Unlock(gWatchdogLock);
         return true;
     }
 
@@ -3490,17 +3490,17 @@ InitWatchdog(JSRuntime *rt)
 
 static void
 KillWatchdog()
 {
     ScheduleWatchdog(gRuntime, -1);
 }
 
 static bool
-ScheduleWatchdog(JSRuntime *rt, double t)
+ScheduleWatchdog(JSRuntime *rt, jsdouble t)
 {
 #ifdef XP_WIN
     if (gTimerHandle) {
         DeleteTimerQueueTimer(NULL, gTimerHandle, NULL);
         gTimerHandle = 0;
     }
     if (t > 0 &&
         !CreateTimerQueueTimer(&gTimerHandle,
@@ -3547,17 +3547,17 @@ CancelExecution(JSRuntime *rt)
     ssize_t dummy = write(2, msg, sizeof(msg) - 1);
     (void)dummy;
 #else
     fputs(msg, stderr);
 #endif
 }
 
 static JSBool
-SetTimeoutValue(JSContext *cx, double t)
+SetTimeoutValue(JSContext *cx, jsdouble t)
 {
     /* NB: The next condition also filter out NaNs. */
     if (!(t <= MAX_TIMEOUT_INTERVAL)) {
         JS_ReportError(cx, "Excessive timeout value");
         return JS_FALSE;
     }
     gTimeoutInterval = t;
     if (!ScheduleWatchdog(cx->runtime, t)) {
@@ -3573,17 +3573,17 @@ Timeout(JSContext *cx, uintN argc, jsval
     if (argc == 0)
         return JS_NewNumberValue(cx, gTimeoutInterval, vp);
 
     if (argc > 1) {
         JS_ReportError(cx, "Wrong number of arguments");
         return JS_FALSE;
     }
 
-    double t;
+    jsdouble t;
     if (!JS_ValueToNumber(cx, JS_ARGV(cx, vp)[0], &t))
         return JS_FALSE;
 
     *vp = JSVAL_VOID;
     return SetTimeoutValue(cx, t);
 }
 
 static JSBool
@@ -3907,17 +3907,17 @@ MJitCodeStats(JSContext *cx, uintN argc,
 JSBool
 MJitChunkLimit(JSContext *cx, uintN argc, jsval *vp)
 {
     if (argc > 1 || argc == 0) {
         JS_ReportError(cx, "Wrong number of arguments");
         return JS_FALSE;
     }
 
-    double t;
+    jsdouble t;
     if (!JS_ValueToNumber(cx, JS_ARGV(cx, vp)[0], &t))
         return JS_FALSE;
 
 #ifdef JS_METHODJIT
     mjit::SetChunkLimit((uint32_t) t);
 #endif
 
     // Clear out analysis information which might refer to code compiled with
--- a/js/src/vm/Debugger.cpp
+++ b/js/src/vm/Debugger.cpp
@@ -1962,17 +1962,17 @@ DebuggerScript_getStartLine(JSContext *c
 }
 
 static JSBool
 DebuggerScript_getLineCount(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getLineCount", args, obj, script);
 
     uintN maxLine = js_GetScriptLineExtent(script);
-    args.rval().setNumber(double(maxLine));
+    args.rval().setNumber(jsdouble(maxLine));
     return true;
 }
 
 static JSBool
 DebuggerScript_getChildScripts(JSContext *cx, uintN argc, Value *vp)
 {
     THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getChildScripts", args, obj, script);
     Debugger *dbg = Debugger::fromChildJSObject(obj);
@@ -2238,17 +2238,17 @@ DebuggerScript_getLineOffsets(JSContext 
 {
     THIS_DEBUGSCRIPT_SCRIPT(cx, argc, vp, "getLineOffsets", args, obj, script);
     REQUIRE_ARGC("Debugger.Script.getLineOffsets", 1);
 
     /* Parse lineno argument. */
     size_t lineno;
     bool ok = false;
     if (args[0].isNumber()) {
-        double d = args[0].toNumber();
+        jsdouble d = args[0].toNumber();
         lineno = size_t(d);
         ok = (lineno == d);
     }
     if (!ok) {
         JS_ReportErrorNumber(cx,  js_GetErrorMessage, NULL, JSMSG_DEBUG_BAD_LINE);
         return false;
     }
 
--- a/js/src/vm/NumberObject-inl.h
+++ b/js/src/vm/NumberObject-inl.h
@@ -48,28 +48,28 @@ JSObject::asNumber()
 {
     JS_ASSERT(isNumber());
     return *static_cast<js::NumberObject *>(this);
 }
 
 namespace js {
 
 inline NumberObject *
-NumberObject::create(JSContext *cx, double d)
+NumberObject::create(JSContext *cx, jsdouble d)
 {
     JSObject *obj = NewBuiltinClassInstance(cx, &NumberClass);
     if (!obj)
         return NULL;
     NumberObject &numobj = obj->asNumber();
     numobj.setPrimitiveValue(d);
     return &numobj;
 }
 
 inline NumberObject *
-NumberObject::createWithProto(JSContext *cx, double d, JSObject &proto)
+NumberObject::createWithProto(JSContext *cx, jsdouble d, JSObject &proto)
 {
     JSObject *obj = NewObjectWithClassProto(cx, &NumberClass, &proto, NULL,
                                             gc::GetGCObjectKind(RESERVED_SLOTS));
     if (!obj)
         return NULL;
     NumberObject &numobj = obj->asNumber();
     numobj.setPrimitiveValue(d);
     return &numobj;
--- a/js/src/vm/NumberObject.h
+++ b/js/src/vm/NumberObject.h
@@ -54,30 +54,30 @@ class NumberObject : public JSObject
 
   public:
     static const uintN RESERVED_SLOTS = 1;
 
     /*
      * Creates a new Number object boxing the given number.  The object's
      * [[Prototype]] is determined from context.
      */
-    static inline NumberObject *create(JSContext *cx, double d);
+    static inline NumberObject *create(JSContext *cx, jsdouble d);
 
     /*
      * Identical to create(), but uses |proto| as [[Prototype]].  This method
      * must not be used to create |Number.prototype|.
      */
-    static inline NumberObject *createWithProto(JSContext *cx, double d, JSObject &proto);
+    static inline NumberObject *createWithProto(JSContext *cx, jsdouble d, JSObject &proto);
 
     double unbox() const {
         return getFixedSlot(PRIMITIVE_VALUE_SLOT).toNumber();
     }
 
   private:
-    inline void setPrimitiveValue(double d) {
+    inline void setPrimitiveValue(jsdouble d) {
         setFixedSlot(PRIMITIVE_VALUE_SLOT, NumberValue(d));
     }
 
     /* For access to init, as Number.prototype is special. */
     friend JSObject *
     ::js_InitNumberClass(JSContext *cx, JSObject *global);
 
   private:
--- a/js/xpconnect/src/XPCComponents.cpp
+++ b/js/xpconnect/src/XPCComponents.cpp
@@ -1423,17 +1423,17 @@ nsXPCComponents_Results::NewResolve(nsIX
         const char* rv_name;
         void* iter = nsnull;
         nsresult rv;
         while (nsXPCException::IterateNSResults(&rv, &rv_name, nsnull, &iter)) {
             if (!strcmp(name.ptr(), rv_name)) {
                 jsval val;
 
                 *objp = obj;
-                if (!JS_NewNumberValue(cx, (double)rv, &val) ||
+                if (!JS_NewNumberValue(cx, (jsdouble)rv, &val) ||
                     !JS_DefinePropertyById(cx, obj, id, val,
                                            nsnull, nsnull,
                                            JSPROP_ENUMERATE |
                                            JSPROP_READONLY |
                                            JSPROP_PERMANENT)) {
                     return NS_ERROR_UNEXPECTED;
                 }
             }
@@ -4160,17 +4160,17 @@ nsXPCComponents::GetProperty(nsIXPConnec
         doResult = true;
     } else if (id == rt->GetStringID(XPCJSRuntime::IDX_RETURN_CODE)) {
         res = xpcc->GetPendingResult();
         doResult = true;
     }
 
     nsresult rv = NS_OK;
     if (doResult) {
-        if (!JS_NewNumberValue(cx, (double) res, vp))
+        if (!JS_NewNumberValue(cx, (jsdouble) res, vp))
             return NS_ERROR_OUT_OF_MEMORY;
         rv = NS_SUCCESS_I_DID_SOMETHING;
     }
 
     return rv;
 }
 
 /* bool setProperty (in nsIXPConnectWrappedNative wrapper, in JSContextPtr cx, in JSObjectPtr obj, in jsid id, in JSValPtr vp); */
--- a/js/xpconnect/src/XPCConvert.cpp
+++ b/js/xpconnect/src/XPCConvert.cpp
@@ -139,21 +139,21 @@ XPCConvert::NativeData2JS(XPCLazyCallCon
 
     if (pErr)
         *pErr = NS_ERROR_XPC_BAD_CONVERT_NATIVE;
 
     switch (type.TagPart()) {
     case nsXPTType::T_I8    : *d = INT_TO_JSVAL(int32_t(*((int8_t*)s)));             break;
     case nsXPTType::T_I16   : *d = INT_TO_JSVAL(int32_t(*((int16_t*)s)));            break;
     case nsXPTType::T_I32   : *d = INT_TO_JSVAL(*((int32_t*)s));                     break;
-    case nsXPTType::T_I64   : *d = DOUBLE_TO_JSVAL(double(*((int64_t*)s)));          break;
+    case nsXPTType::T_I64   : *d = DOUBLE_TO_JSVAL(jsdouble(*((int64_t*)s)));        break;
     case nsXPTType::T_U8    : *d = INT_TO_JSVAL(int32_t(*((uint8_t*)s)));            break;
     case nsXPTType::T_U16   : *d = INT_TO_JSVAL(int32_t(*((uint16_t*)s)));           break;
     case nsXPTType::T_U32   : *d = UINT_TO_JSVAL(*((uint32_t*)s));                   break;
-    case nsXPTType::T_U64   : *d = DOUBLE_TO_JSVAL(double(*((uint64_t*)s)));         break;
+    case nsXPTType::T_U64   : *d = DOUBLE_TO_JSVAL(jsdouble(*((uint64_t*)s)));       break;
     case nsXPTType::T_FLOAT : *d = DOUBLE_TO_JSVAL(*((float*)s));                    break;
     case nsXPTType::T_DOUBLE: *d = DOUBLE_TO_JSVAL(*((double*)s));                   break;
     case nsXPTType::T_BOOL  :
         {
             bool b = *((bool*)s);
 
             NS_WARN_IF_FALSE(b == 1 || b == 0,
                              "Passing a malformed bool through XPConnect");
@@ -405,17 +405,17 @@ XPCConvert::JSData2Native(XPCCallContext
                           nsresult* pErr)
 {
     NS_PRECONDITION(d, "bad param");
 
     JSContext* cx = ccx.GetJSContext();
 
     int32_t  ti;
     uint32_t tu;
-    double td;
+    jsdouble td;
     JSBool   tb;
     JSBool isDOMString = true;
 
     if (pErr)
         *pErr = NS_ERROR_XPC_BAD_CONVERT_JS;
 
     switch (type.TagPart()) {
     case nsXPTType::T_I8     :
--- a/js/xpconnect/src/XPCQuickStubs.h
+++ b/js/xpconnect/src/XPCQuickStubs.h
@@ -230,23 +230,23 @@ xpc_qsThrowBadSetterValue(JSContext *cx,
 JSBool
 xpc_qsGetterOnlyPropertyStub(JSContext *cx, JSObject *obj, jsid id, JSBool strict, jsval *vp);
 
 /* Functions for converting values between COM and JS. */
 
 inline JSBool
 xpc_qsInt64ToJsval(JSContext *cx, PRInt64 i, jsval *rv)
 {
-    return JS_NewNumberValue(cx, static_cast<double>(i), rv);
+    return JS_NewNumberValue(cx, static_cast<jsdouble>(i), rv);
 }
 
 inline JSBool
 xpc_qsUint64ToJsval(JSContext *cx, PRUint64 u, jsval *rv)
 {
-    return JS_NewNumberValue(cx, static_cast<double>(u), rv);
+    return JS_NewNumberValue(cx, static_cast<jsdouble>(u), rv);
 }
 
 
 /* Classes for converting jsvals to string types. */
 
 template <class S, class T>
 class xpc_qsBasicString
 {
@@ -662,17 +662,17 @@ xpc_qsValueToInt64(JSContext *cx,
                    PRInt64 *result)
 {
     if (JSVAL_IS_INT(v)) {
         int32_t intval;
         if (!JS_ValueToECMAInt32(cx, v, &intval))
             return false;
         *result = static_cast<PRInt64>(intval);
     } else {
-        double doubleval;
+        jsdouble doubleval;
         if (!JS_ValueToNumber(cx, v, &doubleval))
             return false;
         *result = static_cast<PRInt64>(doubleval);
     }
     return true;
 }
 
 /**
@@ -684,17 +684,17 @@ xpc_qsValueToUint64(JSContext *cx,
                     PRUint64 *result)
 {
     if (JSVAL_IS_INT(v)) {
         uint32_t intval;
         if (!JS_ValueToECMAUint32(cx, v, &intval))
             return false;
         *result = static_cast<PRUint64>(intval);
     } else {
-        double doubleval;
+        jsdouble doubleval;
         if (!JS_ValueToNumber(cx, v, &doubleval))
             return false;
         *result = static_cast<PRUint64>(doubleval);
     }
     return true;
 }
 
 #ifdef DEBUG
--- a/js/xpconnect/src/codegen.py
+++ b/js/xpconnect/src/codegen.py
@@ -132,23 +132,23 @@ argumentUnboxingTemplates = {
         "        return JS_FALSE;\n",
 
     'unsigned long long':
         "    PRUint64 ${name};\n"
         "    if (!xpc_qsValueToUint64(cx, ${argVal}, &${name}))\n"
         "        return JS_FALSE;\n",
 
     'float':
-        "    double ${name}_dbl;\n"
+        "    jsdouble ${name}_dbl;\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}_dbl))\n"
         "        return JS_FALSE;\n"
         "    float ${name} = (float) ${name}_dbl;\n",
 
     'double':
-        "    double ${name};\n"
+        "    jsdouble ${name};\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}))\n"
         "        return JS_FALSE;\n",
 
     'boolean':
         "    bool ${name};\n"
         "    JS_ValueToBoolean(cx, ${argVal}, &${name});\n",
 
     '[astring]':
--- a/js/xpconnect/src/dombindings.cpp
+++ b/js/xpconnect/src/dombindings.cpp
@@ -598,17 +598,17 @@ getExpandoObject(JSObject *obj)
 }
 
 static int32_t
 IdToInt32(JSContext *cx, jsid id)
 {
     JSAutoRequest ar(cx);
 
     jsval idval;
-    double array_index;
+    jsdouble array_index;
     int32_t i;
     if (!::JS_IdToValue(cx, id, &idval) ||
         !::JS_ValueToNumber(cx, idval, &array_index) ||
         !::JS_DoubleIsInt32(array_index, &i)) {
         return -1;
     }
 
     return i;
--- a/js/xpconnect/src/qsgen.py
+++ b/js/xpconnect/src/qsgen.py
@@ -461,23 +461,23 @@ argumentUnboxingTemplates = {
         "        return JS_FALSE;\n",
 
     'unsigned long long':
         "    PRUint64 ${name};\n"
         "    if (!xpc_qsValueToUint64(cx, ${argVal}, &${name}))\n"
         "        return JS_FALSE;\n",
 
     'float':
-        "    double ${name}_dbl;\n"
+        "    jsdouble ${name}_dbl;\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}_dbl))\n"
         "        return JS_FALSE;\n"
         "    float ${name} = (float) ${name}_dbl;\n",
 
     'double':
-        "    double ${name};\n"
+        "    jsdouble ${name};\n"
         "    if (!JS_ValueToNumber(cx, ${argVal}, &${name}))\n"
         "        return JS_FALSE;\n",
 
     'boolean':
         "    JSBool ${name};\n"
         "    JS_ValueToBoolean(cx, ${argVal}, &${name});\n",
 
     '[astring]':
--- a/toolkit/components/places/Helpers.cpp
+++ b/toolkit/components/places/Helpers.cpp
@@ -464,28 +464,28 @@ livemarkInfoToJSVal(PRInt64 aId,
   NS_ENSURE_SUCCESS(rv, JSVAL_NULL);
   JSContext *cx = nsnull;
   rv = ncc->GetJSContext(&cx);
   NS_ENSURE_SUCCESS(rv, JSVAL_NULL);
   JSObject *obj = JS_NewObject(cx, NULL, NULL, NULL);
   NS_ENSURE_TRUE(obj, JSVAL_NULL); 
 
   jsval id;
-  NS_ENSURE_TRUE(JS_NewNumberValue(cx, double(aId), &id), JSVAL_NULL);
+  NS_ENSURE_TRUE(JS_NewNumberValue(cx, jsdouble(aId), &id), JSVAL_NULL);
 
   JSString* guid = JS_NewStringCopyN(cx, PromiseFlatCString(aGUID).get(),
                                      aGUID.Length());
   NS_ENSURE_TRUE(guid, JSVAL_NULL); 
 
   JSString* title = JS_NewUCStringCopyN(cx, PromiseFlatString(aTitle).get(),
                                         aTitle.Length());
   NS_ENSURE_TRUE(title, JSVAL_NULL); 
 
   jsval parentId;
-  NS_ENSURE_TRUE(JS_NewNumberValue(cx, double(aParentId), &parentId), JSVAL_NULL);
+  NS_ENSURE_TRUE(JS_NewNumberValue(cx, jsdouble(aParentId), &parentId), JSVAL_NULL);
 
   jsval feedURI;
   rv = nsContentUtils::WrapNative(cx, JS_GetGlobalForScopeChain(cx),
                                   NS_ISUPPORTS_CAST(nsIURI*, aFeedURI), &feedURI);
   NS_ENSURE_SUCCESS(rv, JSVAL_NULL);
 
   jsval siteURI;
   rv = nsContentUtils::WrapNative(cx, JS_GetGlobalForScopeChain(cx),
--- a/toolkit/components/places/History.cpp
+++ b/toolkit/components/places/History.cpp
@@ -287,17 +287,17 @@ GetIntFromJSObject(JSContext* aCtx,
   JSBool rc = JS_GetProperty(aCtx, aObject, aProperty, &value);
   NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
   if (JSVAL_IS_VOID(value)) {
     return NS_ERROR_INVALID_ARG;
   }
   NS_ENSURE_ARG(JSVAL_IS_PRIMITIVE(value));
   NS_ENSURE_ARG(JSVAL_IS_NUMBER(value));
 
-  double num;
+  jsdouble num;
   rc = JS_ValueToNumber(aCtx, value, &num);
   NS_ENSURE_TRUE(rc, NS_ERROR_UNEXPECTED);
   NS_ENSURE_ARG(IntType(num) == num);
 
   *_int = IntType(num);
   return NS_OK;
 }