JavaScriptCore-554.1.tar.gz

[apple/javascriptcore.git] / runtime / JSImmediate.h

diff --git a/runtime/JSImmediate.h b/runtime/JSImmediate.h
index 3a448251deff3377ee03258a072c6b673dee6242..4ed35fc45e41ea317ee868007edca36cd63b7f27 100644 (file)
--- a/runtime/JSImmediate.h
+++ b/runtime/JSImmediate.h
@@ -22,6 +22,10 @@
 #ifndef JSImmediate_h
 #define JSImmediate_h
 
 #ifndef JSImmediate_h
 #define JSImmediate_h
 

+#include <wtf/Platform.h>
+
+#if !USE(JSVALUE32_64)
+

 #include <wtf/Assertions.h>
 #include <wtf/AlwaysInline.h>
 #include <wtf/MathExtras.h>
 #include <wtf/Assertions.h>
 #include <wtf/AlwaysInline.h>
 #include <wtf/MathExtras.h>


@@ -42,33 +46,7 @@ namespace JSC {
     class JSObject;
     class UString;
 
     class JSObject;
     class UString;
 

-    JSValuePtr js0();
-    JSValuePtr jsNull();
-    JSValuePtr jsBoolean(bool b);
-    JSValuePtr jsUndefined();
-    JSValuePtr jsImpossibleValue();
-    JSValuePtr jsNumber(ExecState* exec, double d);
-    JSValuePtr jsNumber(ExecState*, char i);
-    JSValuePtr jsNumber(ExecState*, unsigned char i);
-    JSValuePtr jsNumber(ExecState*, short i);
-    JSValuePtr jsNumber(ExecState*, unsigned short i);
-    JSValuePtr jsNumber(ExecState* exec, int i);
-    JSValuePtr jsNumber(ExecState* exec, unsigned i);
-    JSValuePtr jsNumber(ExecState* exec, long i);
-    JSValuePtr jsNumber(ExecState* exec, unsigned long i);
-    JSValuePtr jsNumber(ExecState* exec, long long i);
-    JSValuePtr jsNumber(ExecState* exec, unsigned long long i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, double d);
-    JSValuePtr jsNumber(JSGlobalData* globalData, short i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, unsigned short i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, int i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, unsigned i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, long i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, long long i);
-    JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long long i);
-
-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

     inline intptr_t reinterpretDoubleToIntptr(double value)
     {
         return WTF::bitwise_cast<intptr_t>(value);
     inline intptr_t reinterpretDoubleToIntptr(double value)
     {
         return WTF::bitwise_cast<intptr_t>(value);


@@ -124,7 +102,7 @@ namespace JSC {
 
     /*
      * On 64-bit platforms, we support an alternative encoding form for immediates, if
 
     /*
      * On 64-bit platforms, we support an alternative encoding form for immediates, if

-     * USE(ALTERNATE_JSIMMEDIATE) is defined.  When this format is used, double precision
+     * USE(JSVALUE64) is defined.  When this format is used, double precision

      * floating point values may also be encoded as JSImmediates.
      *
      * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value
      * floating point values may also be encoded as JSImmediates.
      *
      * The encoding makes use of unused NaN space in the IEEE754 representation.  Any value


@@ -158,35 +136,30 @@ namespace JSC {
     class JSImmediate {
     private:
         friend class JIT;
     class JSImmediate {
     private:
         friend class JIT;

-        friend class JSValuePtr;
+        friend class JSValue;

         friend class JSFastMath;
         friend class JSFastMath;

-        friend JSValuePtr js0();
-        friend JSValuePtr jsNull();
-        friend JSValuePtr jsBoolean(bool b);
-        friend JSValuePtr jsUndefined();
-        friend JSValuePtr jsImpossibleValue();
-        friend JSValuePtr jsNumber(ExecState* exec, double d);
-        friend JSValuePtr jsNumber(ExecState*, char i);
-        friend JSValuePtr jsNumber(ExecState*, unsigned char i);
-        friend JSValuePtr jsNumber(ExecState*, short i);
-        friend JSValuePtr jsNumber(ExecState*, unsigned short i);
-        friend JSValuePtr jsNumber(ExecState* exec, int i);
-        friend JSValuePtr jsNumber(ExecState* exec, unsigned i);
-        friend JSValuePtr jsNumber(ExecState* exec, long i);
-        friend JSValuePtr jsNumber(ExecState* exec, unsigned long i);
-        friend JSValuePtr jsNumber(ExecState* exec, long long i);
-        friend JSValuePtr jsNumber(ExecState* exec, unsigned long long i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, double d);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, short i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned short i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, int i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, long i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, long long i);
-        friend JSValuePtr jsNumber(JSGlobalData* globalData, unsigned long long i);
-
-#if USE(ALTERNATE_JSIMMEDIATE)
+        friend JSValue jsNumber(ExecState* exec, double d);
+        friend JSValue jsNumber(ExecState*, char i);
+        friend JSValue jsNumber(ExecState*, unsigned char i);
+        friend JSValue jsNumber(ExecState*, short i);
+        friend JSValue jsNumber(ExecState*, unsigned short i);
+        friend JSValue jsNumber(ExecState* exec, int i);
+        friend JSValue jsNumber(ExecState* exec, unsigned i);
+        friend JSValue jsNumber(ExecState* exec, long i);
+        friend JSValue jsNumber(ExecState* exec, unsigned long i);
+        friend JSValue jsNumber(ExecState* exec, long long i);
+        friend JSValue jsNumber(ExecState* exec, unsigned long long i);
+        friend JSValue jsNumber(JSGlobalData* globalData, double d);
+        friend JSValue jsNumber(JSGlobalData* globalData, short i);
+        friend JSValue jsNumber(JSGlobalData* globalData, unsigned short i);
+        friend JSValue jsNumber(JSGlobalData* globalData, int i);
+        friend JSValue jsNumber(JSGlobalData* globalData, unsigned i);
+        friend JSValue jsNumber(JSGlobalData* globalData, long i);
+        friend JSValue jsNumber(JSGlobalData* globalData, unsigned long i);
+        friend JSValue jsNumber(JSGlobalData* globalData, long long i);
+        friend JSValue jsNumber(JSGlobalData* globalData, unsigned long long i);
+
+#if USE(JSVALUE64)

         // If all bits in the mask are set, this indicates an integer number,
         // if any but not all are set this value is a double precision number.
         static const intptr_t TagTypeNumber = 0xffff000000000000ll;
         // If all bits in the mask are set, this indicates an integer number,
         // if any but not all are set this value is a double precision number.
         static const intptr_t TagTypeNumber = 0xffff000000000000ll;


@@ -208,7 +181,7 @@ namespace JSC {
         static const intptr_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
         static const intptr_t FullTagTypeNull      = TagBitTypeOther;
 
         static const intptr_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
         static const intptr_t FullTagTypeNull      = TagBitTypeOther;
 

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

         static const int32_t IntegerPayloadShift  = 0;
 #else
         static const int32_t IntegerPayloadShift  = 1;
         static const int32_t IntegerPayloadShift  = 0;
 #else
         static const int32_t IntegerPayloadShift  = 1;


@@ -219,107 +192,100 @@ namespace JSC {
 
         static const int32_t signBit = 0x80000000;
  
 
         static const int32_t signBit = 0x80000000;
  

-        static ALWAYS_INLINE bool isImmediate(JSValuePtr v)
+        static ALWAYS_INLINE bool isImmediate(JSValue v)

         {
             return rawValue(v) & TagMask;
         }
         
         {
             return rawValue(v) & TagMask;
         }
         

-        static ALWAYS_INLINE bool isNumber(JSValuePtr v)
+        static ALWAYS_INLINE bool isNumber(JSValue v)

         {
             return rawValue(v) & TagTypeNumber;
         }
 
         {
             return rawValue(v) & TagTypeNumber;
         }
 

-        static ALWAYS_INLINE bool isIntegerNumber(JSValuePtr v)
+        static ALWAYS_INLINE bool isIntegerNumber(JSValue v)

         {
         {

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

             return (rawValue(v) & TagTypeNumber) == TagTypeNumber;
 #else
             return isNumber(v);
 #endif
         }
 
             return (rawValue(v) & TagTypeNumber) == TagTypeNumber;
 #else
             return isNumber(v);
 #endif
         }
 

-#if USE(ALTERNATE_JSIMMEDIATE)
-        static ALWAYS_INLINE bool isDoubleNumber(JSValuePtr v)
+#if USE(JSVALUE64)
+        static ALWAYS_INLINE bool isDouble(JSValue v)

         {
             return isNumber(v) && !isIntegerNumber(v);
         }
 #endif
 
         {
             return isNumber(v) && !isIntegerNumber(v);
         }
 #endif
 

-        static ALWAYS_INLINE bool isPositiveIntegerNumber(JSValuePtr v)
+        static ALWAYS_INLINE bool isPositiveIntegerNumber(JSValue v)

         {
             // A single mask to check for the sign bit and the number tag all at once.
             return (rawValue(v) & (signBit | TagTypeNumber)) == TagTypeNumber;
         }
         
         {
             // A single mask to check for the sign bit and the number tag all at once.
             return (rawValue(v) & (signBit | TagTypeNumber)) == TagTypeNumber;
         }
         

-        static ALWAYS_INLINE bool isBoolean(JSValuePtr v)
+        static ALWAYS_INLINE bool isBoolean(JSValue v)

         {
             return (rawValue(v) & FullTagTypeMask) == FullTagTypeBool;
         }
         
         {
             return (rawValue(v) & FullTagTypeMask) == FullTagTypeBool;
         }
         

-        static ALWAYS_INLINE bool isUndefinedOrNull(JSValuePtr v)
+        static ALWAYS_INLINE bool isUndefinedOrNull(JSValue v)

         {
             // Undefined and null share the same value, bar the 'undefined' bit in the extended tag.
             return (rawValue(v) & ~ExtendedTagBitUndefined) == FullTagTypeNull;
         }
 
         {
             // Undefined and null share the same value, bar the 'undefined' bit in the extended tag.
             return (rawValue(v) & ~ExtendedTagBitUndefined) == FullTagTypeNull;
         }
 

-        static JSValuePtr from(char);
-        static JSValuePtr from(signed char);
-        static JSValuePtr from(unsigned char);
-        static JSValuePtr from(short);
-        static JSValuePtr from(unsigned short);
-        static JSValuePtr from(int);
-        static JSValuePtr from(unsigned);
-        static JSValuePtr from(long);
-        static JSValuePtr from(unsigned long);
-        static JSValuePtr from(long long);
-        static JSValuePtr from(unsigned long long);
-        static JSValuePtr from(double);
+        static JSValue from(char);
+        static JSValue from(signed char);
+        static JSValue from(unsigned char);
+        static JSValue from(short);
+        static JSValue from(unsigned short);
+        static JSValue from(int);
+        static JSValue from(unsigned);
+        static JSValue from(long);
+        static JSValue from(unsigned long);
+        static JSValue from(long long);
+        static JSValue from(unsigned long long);
+        static JSValue from(double);

 
 

-        static ALWAYS_INLINE bool isEitherImmediate(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool isEitherImmediate(JSValue v1, JSValue v2)

         {
             return (rawValue(v1) | rawValue(v2)) & TagMask;
         }
 
         {
             return (rawValue(v1) | rawValue(v2)) & TagMask;
         }
 

-        static ALWAYS_INLINE bool areBothImmediate(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool areBothImmediate(JSValue v1, JSValue v2)

         {
             return isImmediate(v1) & isImmediate(v2);
         }
 
         {
             return isImmediate(v1) & isImmediate(v2);
         }
 

-        static ALWAYS_INLINE bool areBothImmediateIntegerNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool areBothImmediateIntegerNumbers(JSValue v1, JSValue v2)

         {
         {

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

             return (rawValue(v1) & rawValue(v2) & TagTypeNumber) == TagTypeNumber;
 #else
             return rawValue(v1) & rawValue(v2) & TagTypeNumber;
 #endif
         }
 
             return (rawValue(v1) & rawValue(v2) & TagTypeNumber) == TagTypeNumber;
 #else
             return rawValue(v1) & rawValue(v2) & TagTypeNumber;
 #endif
         }
 

-        static double toDouble(JSValuePtr);
-        static bool toBoolean(JSValuePtr);
-        static JSObject* toObject(JSValuePtr, ExecState*);
-        static JSObject* toThisObject(JSValuePtr, ExecState*);
-        static UString toString(JSValuePtr);
-
-        static bool getUInt32(JSValuePtr, uint32_t&);
-        static bool getTruncatedInt32(JSValuePtr, int32_t&);
-        static bool getTruncatedUInt32(JSValuePtr, uint32_t&);
+        static double toDouble(JSValue);
+        static bool toBoolean(JSValue);

 
 

-        static int32_t getTruncatedInt32(JSValuePtr);
-        static uint32_t getTruncatedUInt32(JSValuePtr);
+        static bool getUInt32(JSValue, uint32_t&);
+        static bool getTruncatedInt32(JSValue, int32_t&);
+        static bool getTruncatedUInt32(JSValue, uint32_t&);

 
 

-        static JSValuePtr trueImmediate();
-        static JSValuePtr falseImmediate();
-        static JSValuePtr undefinedImmediate();
-        static JSValuePtr nullImmediate();
-        static JSValuePtr zeroImmediate();
-        static JSValuePtr oneImmediate();
+        static int32_t getTruncatedInt32(JSValue);
+        static uint32_t getTruncatedUInt32(JSValue);

 
 

-        static JSValuePtr impossibleValue();
-        
-        static JSObject* prototype(JSValuePtr, ExecState*);
+        static JSValue trueImmediate();
+        static JSValue falseImmediate();
+        static JSValue undefinedImmediate();
+        static JSValue nullImmediate();
+        static JSValue zeroImmediate();
+        static JSValue oneImmediate();

 
     private:
 
     private:

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

         static const int minImmediateInt = ((-INT_MAX) - 1);
         static const int maxImmediateInt = INT_MAX;
 #else
         static const int minImmediateInt = ((-INT_MAX) - 1);
         static const int maxImmediateInt = INT_MAX;
 #else


@@ -328,199 +294,194 @@ namespace JSC {
 #endif
         static const unsigned maxImmediateUInt = maxImmediateInt;
 
 #endif
         static const unsigned maxImmediateUInt = maxImmediateInt;
 

-        static ALWAYS_INLINE JSValuePtr makeValue(intptr_t integer)
+        static ALWAYS_INLINE JSValue makeValue(intptr_t integer)

         {
         {

-            return JSValuePtr::makeImmediate(integer);
+            return JSValue::makeImmediate(integer);

         }
 
         }
 

-        // With USE(ALTERNATE_JSIMMEDIATE) we want the argument to be zero extended, so the
+        // With USE(JSVALUE64) we want the argument to be zero extended, so the

         // integer doesn't interfere with the tag bits in the upper word.  In the default encoding,
         // if intptr_t id larger then int32_t we sign extend the value through the upper word.
         // integer doesn't interfere with the tag bits in the upper word.  In the default encoding,
         // if intptr_t id larger then int32_t we sign extend the value through the upper word.

-#if USE(ALTERNATE_JSIMMEDIATE)
-        static ALWAYS_INLINE JSValuePtr makeInt(uint32_t value)
+#if USE(JSVALUE64)
+        static ALWAYS_INLINE JSValue makeInt(uint32_t value)

 #else
 #else

-        static ALWAYS_INLINE JSValuePtr makeInt(int32_t value)
+        static ALWAYS_INLINE JSValue makeInt(int32_t value)

 #endif
         {
             return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagTypeNumber);
         }
         
 #endif
         {
             return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagTypeNumber);
         }
         

-#if USE(ALTERNATE_JSIMMEDIATE)
-        static ALWAYS_INLINE JSValuePtr makeDouble(double value)
+#if USE(JSVALUE64)
+        static ALWAYS_INLINE JSValue makeDouble(double value)

         {
             return makeValue(reinterpretDoubleToIntptr(value) + DoubleEncodeOffset);
         }
 #endif
         
         {
             return makeValue(reinterpretDoubleToIntptr(value) + DoubleEncodeOffset);
         }
 #endif
         

-        static ALWAYS_INLINE JSValuePtr makeBool(bool b)
+        static ALWAYS_INLINE JSValue makeBool(bool b)

         {
             return makeValue((static_cast<intptr_t>(b) << ExtendedPayloadShift) | FullTagTypeBool);
         }
         
         {
             return makeValue((static_cast<intptr_t>(b) << ExtendedPayloadShift) | FullTagTypeBool);
         }
         

-        static ALWAYS_INLINE JSValuePtr makeUndefined()
+        static ALWAYS_INLINE JSValue makeUndefined()

         {
             return makeValue(FullTagTypeUndefined);
         }
         
         {
             return makeValue(FullTagTypeUndefined);
         }
         

-        static ALWAYS_INLINE JSValuePtr makeNull()
+        static ALWAYS_INLINE JSValue makeNull()

         {
             return makeValue(FullTagTypeNull);
         }
 
         template<typename T>
         {
             return makeValue(FullTagTypeNull);
         }
 
         template<typename T>

-        static JSValuePtr fromNumberOutsideIntegerRange(T);
+        static JSValue fromNumberOutsideIntegerRange(T);

 
 

-#if USE(ALTERNATE_JSIMMEDIATE)
-        static ALWAYS_INLINE double doubleValue(JSValuePtr v)
+#if USE(JSVALUE64)
+        static ALWAYS_INLINE double doubleValue(JSValue v)

         {
             return reinterpretIntptrToDouble(rawValue(v) - DoubleEncodeOffset);
         }
 #endif
 
         {
             return reinterpretIntptrToDouble(rawValue(v) - DoubleEncodeOffset);
         }
 #endif
 

-        static ALWAYS_INLINE int32_t intValue(JSValuePtr v)
+        static ALWAYS_INLINE int32_t intValue(JSValue v)

         {
             return static_cast<int32_t>(rawValue(v) >> IntegerPayloadShift);
         }
         
         {
             return static_cast<int32_t>(rawValue(v) >> IntegerPayloadShift);
         }
         

-        static ALWAYS_INLINE uint32_t uintValue(JSValuePtr v)
+        static ALWAYS_INLINE uint32_t uintValue(JSValue v)

         {
             return static_cast<uint32_t>(rawValue(v) >> IntegerPayloadShift);
         }
         
         {
             return static_cast<uint32_t>(rawValue(v) >> IntegerPayloadShift);
         }
         

-        static ALWAYS_INLINE bool boolValue(JSValuePtr v)
+        static ALWAYS_INLINE bool boolValue(JSValue v)

         {
             return rawValue(v) & ExtendedPayloadBitBoolValue;
         }
         
         {
             return rawValue(v) & ExtendedPayloadBitBoolValue;
         }
         

-        static ALWAYS_INLINE intptr_t rawValue(JSValuePtr v)
+        static ALWAYS_INLINE intptr_t rawValue(JSValue v)

         {
             return v.immediateValue();
         }
         {
             return v.immediateValue();
         }

-
-        static double nonInlineNaN();

     };
 
     };
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::trueImmediate() { return makeBool(true); }
-    ALWAYS_INLINE JSValuePtr JSImmediate::falseImmediate() { return makeBool(false); }
-    ALWAYS_INLINE JSValuePtr JSImmediate::undefinedImmediate() { return makeUndefined(); }
-    ALWAYS_INLINE JSValuePtr JSImmediate::nullImmediate() { return makeNull(); }
-    ALWAYS_INLINE JSValuePtr JSImmediate::zeroImmediate() { return makeInt(0); }
-    ALWAYS_INLINE JSValuePtr JSImmediate::oneImmediate() { return makeInt(1); }
-
-    // This value is impossible because 0x4 is not a valid pointer but a tag of 0 would indicate non-immediate
-    ALWAYS_INLINE JSValuePtr JSImmediate::impossibleValue() { return makeValue(0x4); }
+    ALWAYS_INLINE JSValue JSImmediate::trueImmediate() { return makeBool(true); }
+    ALWAYS_INLINE JSValue JSImmediate::falseImmediate() { return makeBool(false); }
+    ALWAYS_INLINE JSValue JSImmediate::undefinedImmediate() { return makeUndefined(); }
+    ALWAYS_INLINE JSValue JSImmediate::nullImmediate() { return makeNull(); }
+    ALWAYS_INLINE JSValue JSImmediate::zeroImmediate() { return makeInt(0); }
+    ALWAYS_INLINE JSValue JSImmediate::oneImmediate() { return makeInt(1); }

 
 

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

     inline bool doubleToBoolean(double value)
     {
         return value < 0.0 || value > 0.0;
     }
 
     inline bool doubleToBoolean(double value)
     {
         return value < 0.0 || value > 0.0;
     }
 

-    ALWAYS_INLINE bool JSImmediate::toBoolean(JSValuePtr v)
+    ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)

     {
         ASSERT(isImmediate(v));
         return isNumber(v) ? isIntegerNumber(v) ? v != zeroImmediate()
             : doubleToBoolean(doubleValue(v)) : v == trueImmediate();
     }
 #else
     {
         ASSERT(isImmediate(v));
         return isNumber(v) ? isIntegerNumber(v) ? v != zeroImmediate()
             : doubleToBoolean(doubleValue(v)) : v == trueImmediate();
     }
 #else

-    ALWAYS_INLINE bool JSImmediate::toBoolean(JSValuePtr v)
+    ALWAYS_INLINE bool JSImmediate::toBoolean(JSValue v)

     {
         ASSERT(isImmediate(v));
         return isIntegerNumber(v) ? v != zeroImmediate() : v == trueImmediate();
     }
 #endif
 
     {
         ASSERT(isImmediate(v));
         return isIntegerNumber(v) ? v != zeroImmediate() : v == trueImmediate();
     }
 #endif
 

-    ALWAYS_INLINE uint32_t JSImmediate::getTruncatedUInt32(JSValuePtr v)
+    ALWAYS_INLINE uint32_t JSImmediate::getTruncatedUInt32(JSValue v)

     {
         // FIXME: should probably be asserting isPositiveIntegerNumber here.
         ASSERT(isIntegerNumber(v));
         return intValue(v);
     }
 
     {
         // FIXME: should probably be asserting isPositiveIntegerNumber here.
         ASSERT(isIntegerNumber(v));
         return intValue(v);
     }
 

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

     template<typename T>
     template<typename T>

-    inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T value)
+    inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T value)

     {
         return makeDouble(static_cast<double>(value));
     }
 #else
     template<typename T>
     {
         return makeDouble(static_cast<double>(value));
     }
 #else
     template<typename T>

-    inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T)
+    inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T)

     {
     {

-        return noValue();
+        return JSValue();

     }
 #endif
 
     }
 #endif
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(char i)
+    ALWAYS_INLINE JSValue JSImmediate::from(char i)

     {
         return makeInt(i);
     }
 
     {
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(signed char i)
+    ALWAYS_INLINE JSValue JSImmediate::from(signed char i)

     {
         return makeInt(i);
     }
 
     {
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned char i)
+    ALWAYS_INLINE JSValue JSImmediate::from(unsigned char i)

     {
         return makeInt(i);
     }
 
     {
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(short i)
+    ALWAYS_INLINE JSValue JSImmediate::from(short i)

     {
         return makeInt(i);
     }
 
     {
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned short i)
+    ALWAYS_INLINE JSValue JSImmediate::from(unsigned short i)

     {
         return makeInt(i);
     }
 
     {
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(int i)
+    ALWAYS_INLINE JSValue JSImmediate::from(int i)

     {
     {

-#if !USE(ALTERNATE_JSIMMEDIATE)
+#if !USE(JSVALUE64)

         if ((i < minImmediateInt) | (i > maxImmediateInt))
             return fromNumberOutsideIntegerRange(i);
 #endif
         return makeInt(i);
     }
 
         if ((i < minImmediateInt) | (i > maxImmediateInt))
             return fromNumberOutsideIntegerRange(i);
 #endif
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned i)
+    ALWAYS_INLINE JSValue JSImmediate::from(unsigned i)

     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 
     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(long i)
+    ALWAYS_INLINE JSValue JSImmediate::from(long i)

     {
         if ((i < minImmediateInt) | (i > maxImmediateInt))
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 
     {
         if ((i < minImmediateInt) | (i > maxImmediateInt))
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned long i)
+    ALWAYS_INLINE JSValue JSImmediate::from(unsigned long i)

     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 
     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(i);
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(long long i)
+    ALWAYS_INLINE JSValue JSImmediate::from(long long i)

     {
         if ((i < minImmediateInt) | (i > maxImmediateInt))
     {
         if ((i < minImmediateInt) | (i > maxImmediateInt))

-            return noValue();
+            return JSValue();

         return makeInt(static_cast<intptr_t>(i));
     }
 
         return makeInt(static_cast<intptr_t>(i));
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned long long i)
+    ALWAYS_INLINE JSValue JSImmediate::from(unsigned long long i)

     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(static_cast<intptr_t>(i));
     }
 
     {
         if (i > maxImmediateUInt)
             return fromNumberOutsideIntegerRange(i);
         return makeInt(static_cast<intptr_t>(i));
     }
 

-    ALWAYS_INLINE JSValuePtr JSImmediate::from(double d)
+    ALWAYS_INLINE JSValue JSImmediate::from(double d)

     {
         const int intVal = static_cast<int>(d);
 
     {
         const int intVal = static_cast<int>(d);
 


@@ -531,22 +492,22 @@ namespace JSC {
         return from(intVal);
     }
 
         return from(intVal);
     }
 

-    ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(JSValuePtr v)
+    ALWAYS_INLINE int32_t JSImmediate::getTruncatedInt32(JSValue v)

     {
         ASSERT(isIntegerNumber(v));
         return intValue(v);
     }
 
     {
         ASSERT(isIntegerNumber(v));
         return intValue(v);
     }
 

-    ALWAYS_INLINE double JSImmediate::toDouble(JSValuePtr v)
+    ALWAYS_INLINE double JSImmediate::toDouble(JSValue v)

     {
         ASSERT(isImmediate(v));
 
         if (isIntegerNumber(v))
             return intValue(v);
 
     {
         ASSERT(isImmediate(v));
 
         if (isIntegerNumber(v))
             return intValue(v);
 

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

         if (isNumber(v)) {
         if (isNumber(v)) {

-            ASSERT(isDoubleNumber(v));
+            ASSERT(isDouble(v));

             return doubleValue(v);
         }
 #else
             return doubleValue(v);
         }
 #else


@@ -560,75 +521,64 @@ namespace JSC {
         return rawValue(v) >> ExtendedPayloadShift;
     }
 
         return rawValue(v) >> ExtendedPayloadShift;
     }
 

-    ALWAYS_INLINE bool JSImmediate::getUInt32(JSValuePtr v, uint32_t& i)
+    ALWAYS_INLINE bool JSImmediate::getUInt32(JSValue v, uint32_t& i)

     {
         i = uintValue(v);
         return isPositiveIntegerNumber(v);
     }
 
     {
         i = uintValue(v);
         return isPositiveIntegerNumber(v);
     }
 

-    ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(JSValuePtr v, int32_t& i)
+    ALWAYS_INLINE bool JSImmediate::getTruncatedInt32(JSValue v, int32_t& i)

     {
         i = intValue(v);
         return isIntegerNumber(v);
     }
 
     {
         i = intValue(v);
         return isIntegerNumber(v);
     }
 

-    ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValuePtr v, uint32_t& i)
+    ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValue v, uint32_t& i)

     {
         return getUInt32(v, i);
     }
 
     {
         return getUInt32(v, i);
     }
 

-    inline JSValuePtr js0()
+    inline JSValue::JSValue(JSNullTag)

     {
     {

-        return JSImmediate::zeroImmediate();
+        *this = JSImmediate::nullImmediate();

     }
     }

-
-    inline JSValuePtr jsNull()
+    
+    inline JSValue::JSValue(JSUndefinedTag)

     {
     {

-        return JSImmediate::nullImmediate();
+        *this = JSImmediate::undefinedImmediate();

     }
 
     }
 

-    inline JSValuePtr jsBoolean(bool b)
+    inline JSValue::JSValue(JSTrueTag)

     {
     {

-        return b ? JSImmediate::trueImmediate() : JSImmediate::falseImmediate();
+        *this = JSImmediate::trueImmediate();

     }
 
     }
 

-    inline JSValuePtr jsUndefined()
+    inline JSValue::JSValue(JSFalseTag)

     {
     {

-        return JSImmediate::undefinedImmediate();
+        *this = JSImmediate::falseImmediate();

     }
 
     }
 

-    inline JSValuePtr jsImpossibleValue()
-    {
-        return JSImmediate::impossibleValue();
-    }
-
-    // These are identical logic to the JSValue functions above, and faster than jsNumber(number).toInt32().
-    int32_t toInt32(double);
-    uint32_t toUInt32(double);
-    int32_t toInt32SlowCase(double, bool& ok);
-    uint32_t toUInt32SlowCase(double, bool& ok);
-
-    inline bool JSValuePtr::isUndefined() const
+    inline bool JSValue::isUndefinedOrNull() const

     {
     {

-        return asValue() == jsUndefined();
+        return JSImmediate::isUndefinedOrNull(asValue());

     }
 
     }
 

-    inline bool JSValuePtr::isNull() const
+    inline bool JSValue::isBoolean() const

     {
     {

-        return asValue() == jsNull();
+        return JSImmediate::isBoolean(asValue());

     }
 
     }
 

-    inline bool JSValuePtr::isUndefinedOrNull() const
+    inline bool JSValue::isTrue() const

     {
     {

-        return JSImmediate::isUndefinedOrNull(asValue());
+        return asValue() == JSImmediate::trueImmediate();

     }
 
     }
 

-    inline bool JSValuePtr::isBoolean() const
+    inline bool JSValue::isFalse() const

     {
     {

-        return JSImmediate::isBoolean(asValue());
+        return asValue() == JSImmediate::falseImmediate();

     }
 
     }
 

-    inline bool JSValuePtr::getBoolean(bool& v) const
+    inline bool JSValue::getBoolean(bool& v) const

     {
         if (JSImmediate::isBoolean(asValue())) {
             v = JSImmediate::toBoolean(asValue());
     {
         if (JSImmediate::isBoolean(asValue())) {
             v = JSImmediate::toBoolean(asValue());


@@ -638,194 +588,128 @@ namespace JSC {
         return false;
     }
 
         return false;
     }
 

-    inline bool JSValuePtr::getBoolean() const
+    inline bool JSValue::getBoolean() const

     {
         return asValue() == jsBoolean(true);
     }
 
     {
         return asValue() == jsBoolean(true);
     }
 

-    ALWAYS_INLINE int32_t JSValuePtr::toInt32(ExecState* exec) const
-    {
-        int32_t i;
-        if (getTruncatedInt32(i))
-            return i;
-        bool ignored;
-        return toInt32SlowCase(toNumber(exec), ignored);
-    }
-
-    inline uint32_t JSValuePtr::toUInt32(ExecState* exec) const
-    {
-        uint32_t i;
-        if (getTruncatedUInt32(i))
-            return i;
-        bool ignored;
-        return toUInt32SlowCase(toNumber(exec), ignored);
-    }
-
-    inline int32_t toInt32(double val)
-    {
-        if (!(val >= -2147483648.0 && val < 2147483648.0)) {
-            bool ignored;
-            return toInt32SlowCase(val, ignored);
-        }
-        return static_cast<int32_t>(val);
-    }
-
-    inline uint32_t toUInt32(double val)
-    {
-        if (!(val >= 0.0 && val < 4294967296.0)) {
-            bool ignored;
-            return toUInt32SlowCase(val, ignored);
-        }
-        return static_cast<uint32_t>(val);
-    }
-
-    inline int32_t JSValuePtr::toInt32(ExecState* exec, bool& ok) const
-    {
-        int32_t i;
-        if (getTruncatedInt32(i)) {
-            ok = true;
-            return i;
-        }
-        return toInt32SlowCase(toNumber(exec), ok);
-    }
-
-    inline uint32_t JSValuePtr::toUInt32(ExecState* exec, bool& ok) const
-    {
-        uint32_t i;
-        if (getTruncatedUInt32(i)) {
-            ok = true;
-            return i;
-        }
-        return toUInt32SlowCase(toNumber(exec), ok);
-    }
-
-    inline bool JSValuePtr::isCell() const
+    inline bool JSValue::isCell() const

     {
         return !JSImmediate::isImmediate(asValue());
     }
 
     {
         return !JSImmediate::isImmediate(asValue());
     }
 

-    inline bool JSValuePtr::isInt32Fast() const
+    inline bool JSValue::isInt32() const

     {
         return JSImmediate::isIntegerNumber(asValue());
     }
 
     {
         return JSImmediate::isIntegerNumber(asValue());
     }
 

-    inline int32_t JSValuePtr::getInt32Fast() const
+    inline int32_t JSValue::asInt32() const

     {
     {

-        ASSERT(isInt32Fast());
+        ASSERT(isInt32());

         return JSImmediate::getTruncatedInt32(asValue());
     }
 
         return JSImmediate::getTruncatedInt32(asValue());
     }
 

-    inline bool JSValuePtr::isUInt32Fast() const
+    inline bool JSValue::isUInt32() const

     {
         return JSImmediate::isPositiveIntegerNumber(asValue());
     }
 
     {
         return JSImmediate::isPositiveIntegerNumber(asValue());
     }
 

-    inline uint32_t JSValuePtr::getUInt32Fast() const
+    inline uint32_t JSValue::asUInt32() const

     {
     {

-        ASSERT(isUInt32Fast());
+        ASSERT(isUInt32());

         return JSImmediate::getTruncatedUInt32(asValue());
     }
 
         return JSImmediate::getTruncatedUInt32(asValue());
     }
 

-    inline JSValuePtr JSValuePtr::makeInt32Fast(int32_t i)
-    {
-        return JSImmediate::from(i);
-    }
-
-    inline bool JSValuePtr::areBothInt32Fast(JSValuePtr v1, JSValuePtr v2)
-    {
-        return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
-    }
-

     class JSFastMath {
     public:
     class JSFastMath {
     public:

-        static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValue v1, JSValue v2)

         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
         }
 
         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
         }
 

-        static ALWAYS_INLINE JSValuePtr equal(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue equal(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return jsBoolean(v1 == v2);
         }
 
         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return jsBoolean(v1 == v2);
         }
 

-        static ALWAYS_INLINE JSValuePtr notEqual(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue notEqual(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return jsBoolean(v1 != v2);
         }
 
         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return jsBoolean(v1 != v2);
         }
 

-        static ALWAYS_INLINE JSValuePtr andImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue andImmediateNumbers(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) & JSImmediate::rawValue(v2));
         }
 
         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) & JSImmediate::rawValue(v2));
         }
 

-        static ALWAYS_INLINE JSValuePtr xorImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue xorImmediateNumbers(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue((JSImmediate::rawValue(v1) ^ JSImmediate::rawValue(v2)) | JSImmediate::TagTypeNumber);
         }
 
         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue((JSImmediate::rawValue(v1) ^ JSImmediate::rawValue(v2)) | JSImmediate::TagTypeNumber);
         }
 

-        static ALWAYS_INLINE JSValuePtr orImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue orImmediateNumbers(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) | JSImmediate::rawValue(v2));
         }
 
         {
             ASSERT(canDoFastBitwiseOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) | JSImmediate::rawValue(v2));
         }
 

-        static ALWAYS_INLINE bool canDoFastRshift(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool canDoFastRshift(JSValue v1, JSValue v2)

         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
         }
 
         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2);
         }
 

-        static ALWAYS_INLINE bool canDoFastUrshift(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool canDoFastUrshift(JSValue v1, JSValue v2)

         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2) && !(JSImmediate::rawValue(v1) & JSImmediate::signBit);
         }
 
         {
             return JSImmediate::areBothImmediateIntegerNumbers(v1, v2) && !(JSImmediate::rawValue(v1) & JSImmediate::signBit);
         }
 

-        static ALWAYS_INLINE JSValuePtr rightShiftImmediateNumbers(JSValuePtr val, JSValuePtr shift)
+        static ALWAYS_INLINE JSValue rightShiftImmediateNumbers(JSValue val, JSValue shift)

         {
             ASSERT(canDoFastRshift(val, shift) || canDoFastUrshift(val, shift));
         {
             ASSERT(canDoFastRshift(val, shift) || canDoFastUrshift(val, shift));

-#if USE(ALTERNATE_JSIMMEDIATE)
+#if USE(JSVALUE64)

             return JSImmediate::makeValue(static_cast<intptr_t>(static_cast<uint32_t>(static_cast<int32_t>(JSImmediate::rawValue(val)) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f))) | JSImmediate::TagTypeNumber);
 #else
             return JSImmediate::makeValue((JSImmediate::rawValue(val) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f)) | JSImmediate::TagTypeNumber);
 #endif
         }
 
             return JSImmediate::makeValue(static_cast<intptr_t>(static_cast<uint32_t>(static_cast<int32_t>(JSImmediate::rawValue(val)) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f))) | JSImmediate::TagTypeNumber);
 #else
             return JSImmediate::makeValue((JSImmediate::rawValue(val) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f)) | JSImmediate::TagTypeNumber);
 #endif
         }
 

-        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr v)
+        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v)

         {
             // Number is non-negative and an operation involving two of these can't overflow.
             // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
             return (JSImmediate::rawValue(v) & (JSImmediate::TagTypeNumber + (JSImmediate::signBit | (JSImmediate::signBit >> 1)))) == JSImmediate::TagTypeNumber;
         }
 
         {
             // Number is non-negative and an operation involving two of these can't overflow.
             // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
             return (JSImmediate::rawValue(v) & (JSImmediate::TagTypeNumber + (JSImmediate::signBit | (JSImmediate::signBit >> 1)))) == JSImmediate::TagTypeNumber;
         }
 

-        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValue v1, JSValue v2)

         {
             // Number is non-negative and an operation involving two of these can't overflow.
             // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
             return canDoFastAdditiveOperations(v1) && canDoFastAdditiveOperations(v2);
         }
 
         {
             // Number is non-negative and an operation involving two of these can't overflow.
             // Checking for allowed negative numbers takes more time than it's worth on SunSpider.
             return canDoFastAdditiveOperations(v1) && canDoFastAdditiveOperations(v2);
         }
 

-        static ALWAYS_INLINE JSValuePtr addImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue addImmediateNumbers(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastAdditiveOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) + JSImmediate::rawValue(v2) - JSImmediate::TagTypeNumber);
         }
 
         {
             ASSERT(canDoFastAdditiveOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) + JSImmediate::rawValue(v2) - JSImmediate::TagTypeNumber);
         }
 

-        static ALWAYS_INLINE JSValuePtr subImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        static ALWAYS_INLINE JSValue subImmediateNumbers(JSValue v1, JSValue v2)

         {
             ASSERT(canDoFastAdditiveOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) - JSImmediate::rawValue(v2) + JSImmediate::TagTypeNumber);
         }
 
         {
             ASSERT(canDoFastAdditiveOperations(v1, v2));
             return JSImmediate::makeValue(JSImmediate::rawValue(v1) - JSImmediate::rawValue(v2) + JSImmediate::TagTypeNumber);
         }
 

-        static ALWAYS_INLINE JSValuePtr incImmediateNumber(JSValuePtr v)
+        static ALWAYS_INLINE JSValue incImmediateNumber(JSValue v)

         {
             ASSERT(canDoFastAdditiveOperations(v));
             return JSImmediate::makeValue(JSImmediate::rawValue(v) + (1 << JSImmediate::IntegerPayloadShift));
         }
 
         {
             ASSERT(canDoFastAdditiveOperations(v));
             return JSImmediate::makeValue(JSImmediate::rawValue(v) + (1 << JSImmediate::IntegerPayloadShift));
         }
 

-        static ALWAYS_INLINE JSValuePtr decImmediateNumber(JSValuePtr v)
+        static ALWAYS_INLINE JSValue decImmediateNumber(JSValue v)

         {
             ASSERT(canDoFastAdditiveOperations(v));
             return JSImmediate::makeValue(JSImmediate::rawValue(v) - (1 << JSImmediate::IntegerPayloadShift));
         {
             ASSERT(canDoFastAdditiveOperations(v));
             return JSImmediate::makeValue(JSImmediate::rawValue(v) - (1 << JSImmediate::IntegerPayloadShift));


@@ -834,4 +718,6 @@ namespace JSC {
 
 } // namespace JSC
 
 
 } // namespace JSC
 

+#endif // !USE(JSVALUE32_64)
+

 #endif // JSImmediate_h
 #endif // JSImmediate_h