2009-01-13 Gavin Barraclough <barraclough@apple.com>
[WebKit-https.git] / JavaScriptCore / runtime / JSImmediate.h
index 37bca2a..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
@@ -99,7 +126,34 @@ namespace JSC {
     class JSImmediate {
     private:
         friend class JIT;
-    
+        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
@@ -128,7 +182,6 @@ namespace JSC {
 
         static const int32_t signBit = 0x80000000;
  
-    public:
         static ALWAYS_INLINE bool isImmediate(JSValuePtr v)
         {
             return rawValue(v) & TagMask;
@@ -180,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);
@@ -195,67 +243,6 @@ namespace JSC {
             return rawValue(v1) & rawValue(v2) & TagTypeInteger;
         }
 
-        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)) | TagTypeInteger);
-        }
-
-        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));
-#if USE(ALTERNATE_JSIMMEDIATE)
-            return makeValue(static_cast<intptr_t>(static_cast<uint32_t>(static_cast<int32_t>(rawValue(val)) >> ((rawValue(shift) >> IntegerPayloadShift) & 0x1f))) | TagTypeInteger);
-#else
-            return makeValue((rawValue(val) >> ((rawValue(shift) >> IntegerPayloadShift) & 0x1f)) | 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 (rawValue(v) & (TagTypeInteger + (signBit | (signBit >> 1)))) == TagTypeInteger;
-        }
-
-        static ALWAYS_INLINE JSValuePtr addImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(canDoFastAdditiveOperations(v1));
-            ASSERT(canDoFastAdditiveOperations(v2));
-            return makeValue(rawValue(v1) + rawValue(v2) - TagTypeInteger);
-        }
-
-        static ALWAYS_INLINE JSValuePtr subImmediateNumbers(JSValuePtr v1, JSValuePtr v2)
-        {
-            ASSERT(canDoFastAdditiveOperations(v1));
-            ASSERT(canDoFastAdditiveOperations(v2));
-            return makeValue(rawValue(v1) - rawValue(v2) + TagTypeInteger);
-        }
-
-        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));
-        }
-
         static double toDouble(JSValuePtr);
         static bool toBoolean(JSValuePtr);
         static JSObject* toObject(JSValuePtr, ExecState*);
@@ -484,6 +471,11 @@ namespace JSC {
         return getUInt32(v, i);
     }
 
+    inline JSValuePtr js0()
+    {
+        return JSImmediate::zeroImmediate();
+    }
+
     inline JSValuePtr jsNull()
     {
         return JSImmediate::nullImmediate();
@@ -499,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());
@@ -535,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)
@@ -576,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