2009-01-13 Gavin Barraclough <barraclough@apple.com>
[WebKit-https.git] / JavaScriptCore / runtime / JSImmediate.h
index bd0eccc..05aea6f 100644 (file)
@@ -36,10 +36,37 @@ namespace JSC {
 
     class ExecState;
     class JSCell;
+    class JSFastMath;
+    class JSGlobalData;
     class JSObject;
-    class JSValue;
     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);
+
     /*
      * A JSValue* is either a pointer to a cell (a heap-allocated object) or an immediate (a type-tagged 
      * value masquerading as a pointer). The low two bits in a JSValue* are available for type tagging
@@ -82,35 +109,79 @@ namespace JSC {
      *                      [ zero ]                       [ zero ]       [ tag 'other' ]
      */
 
+    /*
+     * On 64-bit platforms, we support an alternative encoding form for immediates, if
+     * USE(ALTERNATE_JSIMMEDIATE) is defined.
+     *
+     * The top 16-bits denote the type:
+     *
+     * Pointer: 0000:PPPP:PPPP:PPPP
+     * Integer: FFFF:0000:IIII:IIII
+     *
+     * 32-bit signed integers are marked with the 16-bit tag '0xFFFF'.  The tag '0x0000'
+     * denotes a pointer, or another form of tagged immediate.  Boolean, null and undefined
+     * values are encoded in the same manner as the default format.
+     */
+
     class JSImmediate {
     private:
         friend class JIT;
-    
-        static const int32_t TagMask           = 0x3; // primary tag is 2 bits long
-        static const int32_t TagBitTypeInteger = 0x1; // bottom bit set indicates integer, this dominates the following bit
-        static const int32_t TagBitTypeOther   = 0x2; // second bit set indicates immediate other than an integer
+        friend class JSValuePtr;
+        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)
+        static const intptr_t TagTypeInteger = 0xffff000000000000ll; // bottom bit set indicates integer, this dominates the following bit
+#else
+        static const intptr_t TagTypeInteger = 0x1; // bottom bit set indicates integer, this dominates the following bit
+#endif
+        static const intptr_t TagBitTypeOther   = 0x2; // second bit set indicates immediate other than an integer
+        static const intptr_t TagMask           = TagTypeInteger | TagBitTypeOther;
 
-        static const int32_t ExtendedTagMask         = 0xC; // extended tag holds a further two bits
-        static const int32_t ExtendedTagBitBool      = 0x4;
-        static const int32_t ExtendedTagBitUndefined = 0x8;
+        static const intptr_t ExtendedTagMask         = 0xC; // extended tag holds a further two bits
+        static const intptr_t ExtendedTagBitBool      = 0x4;
+        static const intptr_t ExtendedTagBitUndefined = 0x8;
 
-        static const int32_t FullTagTypeMask      = TagMask | ExtendedTagMask;
-        static const int32_t FullTagTypeBool      = TagBitTypeOther | ExtendedTagBitBool;
-        static const int32_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
-        static const int32_t FullTagTypeNull      = TagBitTypeOther;
+        static const intptr_t FullTagTypeMask      = TagMask | ExtendedTagMask;
+        static const intptr_t FullTagTypeBool      = TagBitTypeOther | ExtendedTagBitBool;
+        static const intptr_t FullTagTypeUndefined = TagBitTypeOther | ExtendedTagBitUndefined;
+        static const intptr_t FullTagTypeNull      = TagBitTypeOther;
 
+#if USE(ALTERNATE_JSIMMEDIATE)
+        static const int32_t IntegerPayloadShift  = 0;
+#else
         static const int32_t IntegerPayloadShift  = 1;
+#endif
         static const int32_t ExtendedPayloadShift = 4;
 
-        static const int32_t ExtendedPayloadBitBoolValue = 1 << ExtendedPayloadShift;
+        static const intptr_t ExtendedPayloadBitBoolValue = 1 << ExtendedPayloadShift;
 
-#if USE(ALTERNATE_JSIMMEDIATE)
-        static const intptr_t signBit = 0x100000000ll;
-#else
         static const int32_t signBit = 0x80000000;
-#endif
  
-    public:
         static ALWAYS_INLINE bool isImmediate(JSValuePtr v)
         {
             return rawValue(v) & TagMask;
@@ -118,13 +189,13 @@ namespace JSC {
         
         static ALWAYS_INLINE bool isNumber(JSValuePtr v)
         {
-            return rawValue(v) & TagBitTypeInteger;
+            return rawValue(v) & TagTypeInteger;
         }
 
         static ALWAYS_INLINE bool isPositiveNumber(JSValuePtr v)
         {
             // A single mask to check for the sign bit and the number tag all at once.
-            return (rawValue(v) & (signBit | TagBitTypeInteger)) == TagBitTypeInteger;
+            return (rawValue(v) & (signBit | TagTypeInteger)) == TagTypeInteger;
         }
         
         static ALWAYS_INLINE bool isBoolean(JSValuePtr v)
@@ -162,11 +233,6 @@ namespace JSC {
             return (rawValue(v1) | rawValue(v2)) & TagMask;
         }
 
-        static ALWAYS_INLINE bool isAnyImmediate(JSValuePtr v1, JSValuePtr v2, JSValuePtr v3)
-        {
-            return (rawValue(v1) | rawValue(v2) | rawValue(v3)) & TagMask;
-        }
-
         static ALWAYS_INLINE bool areBothImmediate(JSValuePtr v1, JSValuePtr v2)
         {
             return isImmediate(v1) & isImmediate(v2);
@@ -174,64 +240,7 @@ namespace JSC {
 
         static ALWAYS_INLINE bool areBothImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
         {
-            return rawValue(v1) & rawValue(v2) & TagBitTypeInteger;
-        }
-
-        static ALWAYS_INLINE JSValuePtr andImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(areBothImmediateNumbers(v1, v2));
-            return makeValue(rawValue(v1) & rawValue(v2));
-        }
-
-        static ALWAYS_INLINE JSValuePtr xorImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(areBothImmediateNumbers(v1, v2));
-            return makeValue((rawValue(v1) ^ rawValue(v2)) | TagBitTypeInteger);
-        }
-
-        static ALWAYS_INLINE JSValuePtr orImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(areBothImmediateNumbers(v1, v2));
-            return makeValue(rawValue(v1) | rawValue(v2));
-        }
-
-        static ALWAYS_INLINE JSValuePtr rightShiftImmediateNumbers(JSValuePtr val, JSValuePtr shift)
-        {
-            ASSERT(areBothImmediateNumbers(val, shift));
-            return makeValue((rawValue(val) >> ((rawValue(shift) >> IntegerPayloadShift) & 0x1f)) | TagBitTypeInteger);
-        }
-
-        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr 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 (rawValue(v) & (TagBitTypeInteger + (signBit | (signBit >> 1)))) == TagBitTypeInteger;
-        }
-
-        static ALWAYS_INLINE JSValuePtr addImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(canDoFastAdditiveOperations(v1));
-            ASSERT(canDoFastAdditiveOperations(v2));
-            return makeValue(rawValue(v1) + rawValue(v2) - TagBitTypeInteger);
-        }
-
-        static ALWAYS_INLINE JSValuePtr subImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(canDoFastAdditiveOperations(v1));
-            ASSERT(canDoFastAdditiveOperations(v2));
-            return makeValue(rawValue(v1) - rawValue(v2) + TagBitTypeInteger);
-        }
-
-        static ALWAYS_INLINE JSValuePtr incImmediateNumber(JSValuePtr v)
-        {
-            ASSERT(canDoFastAdditiveOperations(v));
-            return makeValue(rawValue(v) + (1 << IntegerPayloadShift));
-        }
-
-        static ALWAYS_INLINE JSValuePtr decImmediateNumber(JSValuePtr v)
-        {
-            ASSERT(canDoFastAdditiveOperations(v));
-            return makeValue(rawValue(v) - (1 << IntegerPayloadShift));
+            return rawValue(v1) & rawValue(v2) & TagTypeInteger;
         }
 
         static double toDouble(JSValuePtr);
@@ -273,9 +282,13 @@ namespace JSC {
             return JSValuePtr::makeImmediate(integer);
         }
 
+#if USE(ALTERNATE_JSIMMEDIATE)
+        static ALWAYS_INLINE JSValuePtr makeInt(uint32_t value)
+#else
         static ALWAYS_INLINE JSValuePtr makeInt(int32_t value)
+#endif
         {
-            return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagBitTypeInteger);
+            return makeValue((static_cast<intptr_t>(value) << IntegerPayloadShift) | TagTypeInteger);
         }
         
         static ALWAYS_INLINE JSValuePtr makeBool(bool b)
@@ -330,8 +343,8 @@ namespace JSC {
     {
         ASSERT(isImmediate(v));
         intptr_t bits = rawValue(v);
-        return (bits & TagBitTypeInteger)
-            ? bits != TagBitTypeInteger // !0 ints
+        return (bits & TagTypeInteger)
+            ? bits != TagTypeInteger // !0 ints
             : bits == (FullTagTypeBool | ExtendedPayloadBitBoolValue); // bool true
     }
 
@@ -458,6 +471,11 @@ namespace JSC {
         return getUInt32(v, i);
     }
 
+    inline JSValuePtr js0()
+    {
+        return JSImmediate::zeroImmediate();
+    }
+
     inline JSValuePtr jsNull()
     {
         return JSImmediate::nullImmediate();
@@ -473,33 +491,38 @@ namespace JSC {
         return JSImmediate::undefinedImmediate();
     }
 
+    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 JSValue::isUndefined() const
+    inline bool JSValuePtr::isUndefined() const
     {
         return asValue() == jsUndefined();
     }
 
-    inline bool JSValue::isNull() const
+    inline bool JSValuePtr::isNull() const
     {
         return asValue() == jsNull();
     }
 
-    inline bool JSValue::isUndefinedOrNull() const
+    inline bool JSValuePtr::isUndefinedOrNull() const
     {
         return JSImmediate::isUndefinedOrNull(asValue());
     }
 
-    inline bool JSValue::isBoolean() const
+    inline bool JSValuePtr::isBoolean() const
     {
         return JSImmediate::isBoolean(asValue());
     }
 
-    inline bool JSValue::getBoolean(bool& v) const
+    inline bool JSValuePtr::getBoolean(bool& v) const
     {
         if (JSImmediate::isBoolean(asValue())) {
             v = JSImmediate::toBoolean(asValue());
@@ -509,27 +532,27 @@ namespace JSC {
         return false;
     }
 
-    inline bool JSValue::getBoolean() const
+    inline bool JSValuePtr::getBoolean() const
     {
         return asValue() == jsBoolean(true);
     }
 
-    ALWAYS_INLINE int32_t JSValue::toInt32(ExecState* exec) const
+    ALWAYS_INLINE int32_t JSValuePtr::toInt32(ExecState* exec) const
     {
         int32_t i;
         if (getTruncatedInt32(i))
             return i;
-        bool ok;
-        return toInt32SlowCase(exec, ok);
+        bool ignored;
+        return toInt32SlowCase(toNumber(exec), ignored);
     }
 
-    inline uint32_t JSValue::toUInt32(ExecState* exec) const
+    inline uint32_t JSValuePtr::toUInt32(ExecState* exec) const
     {
         uint32_t i;
         if (getTruncatedUInt32(i))
             return i;
-        bool ok;
-        return toUInt32SlowCase(exec, ok);
+        bool ignored;
+        return toUInt32SlowCase(toNumber(exec), ignored);
     }
 
     inline int32_t toInt32(double val)
@@ -550,26 +573,159 @@ namespace JSC {
         return static_cast<uint32_t>(val);
     }
 
-    inline int32_t JSValue::toInt32(ExecState* exec, bool& ok) const
+    inline int32_t JSValuePtr::toInt32(ExecState* exec, bool& ok) const
     {
         int32_t i;
         if (getTruncatedInt32(i)) {
             ok = true;
             return i;
         }
-        return toInt32SlowCase(exec, ok);
+        return toInt32SlowCase(toNumber(exec), ok);
     }
 
-    inline uint32_t JSValue::toUInt32(ExecState* exec, bool& ok) const
+    inline uint32_t JSValuePtr::toUInt32(ExecState* exec, bool& ok) const
     {
         uint32_t i;
         if (getTruncatedUInt32(i)) {
             ok = true;
             return i;
         }
-        return toUInt32SlowCase(exec, ok);
+        return toUInt32SlowCase(toNumber(exec), ok);
+    }
+
+    inline bool JSValuePtr::isCell() const
+    {
+        return !JSImmediate::isImmediate(asValue());
+    }
+
+    inline bool JSValuePtr::isInt32Fast() const
+    {
+        return JSImmediate::isNumber(asValue());
+    }
+
+    inline int32_t JSValuePtr::getInt32Fast() const
+    {
+        ASSERT(isInt32Fast());
+        return JSImmediate::getTruncatedInt32(asValue());
+    }
+
+    inline bool JSValuePtr::isUInt32Fast() const
+    {
+        return JSImmediate::isPositiveNumber(asValue());
+    }
+
+    inline uint32_t JSValuePtr::getUInt32Fast() const
+    {
+        ASSERT(isUInt32Fast());
+        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::areBothImmediateNumbers(v1, v2);
+    }
+
+    class JSFastMath {
+    public:
+        static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValuePtr v1, JSValuePtr v2)
+        {
+            return JSImmediate::areBothImmediateNumbers(v1, v2);
+        }
+
+        static ALWAYS_INLINE JSValuePtr equal(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastBitwiseOperations(v1, v2));
+            return jsBoolean(v1 == v2);
+        }
+
+        static ALWAYS_INLINE JSValuePtr notEqual(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastBitwiseOperations(v1, v2));
+            return jsBoolean(v1 != v2);
+        }
+
+        static ALWAYS_INLINE JSValuePtr andImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastBitwiseOperations(v1, v2));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v1) & JSImmediate::rawValue(v2));
+        }
+
+        static ALWAYS_INLINE JSValuePtr xorImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastBitwiseOperations(v1, v2));
+            return JSImmediate::makeValue((JSImmediate::rawValue(v1) ^ JSImmediate::rawValue(v2)) | JSImmediate::TagTypeInteger);
+        }
+
+        static ALWAYS_INLINE JSValuePtr orImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastBitwiseOperations(v1, v2));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v1) | JSImmediate::rawValue(v2));
+        }
+
+        static ALWAYS_INLINE bool canDoFastRshift(JSValuePtr v1, JSValuePtr v2)
+        {
+            return JSImmediate::areBothImmediateNumbers(v1, v2);
+        }
+
+        static ALWAYS_INLINE bool canDoFastUrshift(JSValuePtr v1, JSValuePtr v2)
+        {
+            return JSImmediate::areBothImmediateNumbers(v1, v2) && !JSImmediate::isNegative(v1);
+        }
+
+        static ALWAYS_INLINE JSValuePtr rightShiftImmediateNumbers(JSValuePtr val, JSValuePtr shift)
+        {
+            ASSERT(canDoFastRshift(val, shift) || canDoFastUrshift(val, shift));
+#if USE(ALTERNATE_JSIMMEDIATE)
+            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::TagTypeInteger);
+#else
+            return JSImmediate::makeValue((JSImmediate::rawValue(val) >> ((JSImmediate::rawValue(shift) >> JSImmediate::IntegerPayloadShift) & 0x1f)) | JSImmediate::TagTypeInteger);
+#endif
+        }
+
+        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr 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::TagTypeInteger + (JSImmediate::signBit | (JSImmediate::signBit >> 1)))) == JSImmediate::TagTypeInteger;
+        }
+
+        static ALWAYS_INLINE bool canDoFastAdditiveOperations(JSValuePtr v1, JSValuePtr 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)
+        {
+            ASSERT(canDoFastAdditiveOperations(v1, v2));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v1) + JSImmediate::rawValue(v2) - JSImmediate::TagTypeInteger);
+        }
+
+        static ALWAYS_INLINE JSValuePtr subImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
+        {
+            ASSERT(canDoFastAdditiveOperations(v1, v2));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v1) - JSImmediate::rawValue(v2) + JSImmediate::TagTypeInteger);
+        }
+
+        static ALWAYS_INLINE JSValuePtr incImmediateNumber(JSValuePtr v)
+        {
+            ASSERT(canDoFastAdditiveOperations(v));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v) + (1 << JSImmediate::IntegerPayloadShift));
+        }
+
+        static ALWAYS_INLINE JSValuePtr decImmediateNumber(JSValuePtr v)
+        {
+            ASSERT(canDoFastAdditiveOperations(v));
+            return JSImmediate::makeValue(JSImmediate::rawValue(v) - (1 << JSImmediate::IntegerPayloadShift));
+        }
+    };
+
 } // namespace JSC
 
 #endif // JSImmediate_h