X-Git-Url: https://git.saurik.com/apple/javascriptcore.git/blobdiff_plain/9dae56ea45a0f5f8136a5c93d6f3a7f99399ca73..ba379fdc102753d6be2c4d937058fe40257329fe:/runtime/JSImmediate.h diff --git a/runtime/JSImmediate.h b/runtime/JSImmediate.h index 3a44825..4ed35fc 100644 --- a/runtime/JSImmediate.h +++ b/runtime/JSImmediate.h @@ -22,6 +22,10 @@ #ifndef JSImmediate_h #define JSImmediate_h +#include + +#if !USE(JSVALUE32_64) + #include #include #include @@ -42,33 +46,7 @@ namespace JSC { 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(value); @@ -124,7 +102,7 @@ namespace JSC { /* * 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 @@ -158,35 +136,30 @@ namespace JSC { class JSImmediate { private: friend class JIT; - friend class JSValuePtr; + friend class JSValue; 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; @@ -208,7 +181,7 @@ namespace JSC { 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; @@ -219,107 +192,100 @@ namespace JSC { static const int32_t signBit = 0x80000000; - static ALWAYS_INLINE bool isImmediate(JSValuePtr v) + static ALWAYS_INLINE bool isImmediate(JSValue v) { return rawValue(v) & TagMask; } - static ALWAYS_INLINE bool isNumber(JSValuePtr v) + static ALWAYS_INLINE bool isNumber(JSValue v) { 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 } -#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 - 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; } - static ALWAYS_INLINE bool isBoolean(JSValuePtr v) + static ALWAYS_INLINE bool isBoolean(JSValue v) { 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; } - 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; } - static ALWAYS_INLINE bool areBothImmediate(JSValuePtr v1, JSValuePtr v2) + static ALWAYS_INLINE bool areBothImmediate(JSValue v1, JSValue 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 } - 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: -#if USE(ALTERNATE_JSIMMEDIATE) +#if USE(JSVALUE64) 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; - 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. -#if USE(ALTERNATE_JSIMMEDIATE) - static ALWAYS_INLINE JSValuePtr makeInt(uint32_t value) +#if USE(JSVALUE64) + static ALWAYS_INLINE JSValue makeInt(uint32_t value) #else - static ALWAYS_INLINE JSValuePtr makeInt(int32_t value) + static ALWAYS_INLINE JSValue makeInt(int32_t value) #endif { return makeValue((static_cast(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 - static ALWAYS_INLINE JSValuePtr makeBool(bool b) + static ALWAYS_INLINE JSValue makeBool(bool b) { return makeValue((static_cast(b) << ExtendedPayloadShift) | FullTagTypeBool); } - static ALWAYS_INLINE JSValuePtr makeUndefined() + static ALWAYS_INLINE JSValue makeUndefined() { return makeValue(FullTagTypeUndefined); } - static ALWAYS_INLINE JSValuePtr makeNull() + static ALWAYS_INLINE JSValue makeNull() { return makeValue(FullTagTypeNull); } template - 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 - static ALWAYS_INLINE int32_t intValue(JSValuePtr v) + static ALWAYS_INLINE int32_t intValue(JSValue v) { return static_cast(rawValue(v) >> IntegerPayloadShift); } - static ALWAYS_INLINE uint32_t uintValue(JSValuePtr v) + static ALWAYS_INLINE uint32_t uintValue(JSValue v) { return static_cast(rawValue(v) >> IntegerPayloadShift); } - static ALWAYS_INLINE bool boolValue(JSValuePtr v) + static ALWAYS_INLINE bool boolValue(JSValue v) { return rawValue(v) & ExtendedPayloadBitBoolValue; } - static ALWAYS_INLINE intptr_t rawValue(JSValuePtr v) + static ALWAYS_INLINE intptr_t rawValue(JSValue v) { 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; } - 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 - 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 - 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); } -#if USE(ALTERNATE_JSIMMEDIATE) +#if USE(JSVALUE64) template - inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T value) + inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T value) { return makeDouble(static_cast(value)); } #else template - inline JSValuePtr JSImmediate::fromNumberOutsideIntegerRange(T) + inline JSValue JSImmediate::fromNumberOutsideIntegerRange(T) { - return noValue(); + return JSValue(); } #endif - ALWAYS_INLINE JSValuePtr JSImmediate::from(char i) + ALWAYS_INLINE JSValue JSImmediate::from(char i) { return makeInt(i); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(signed char i) + ALWAYS_INLINE JSValue JSImmediate::from(signed char i) { return makeInt(i); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned char i) + ALWAYS_INLINE JSValue JSImmediate::from(unsigned char i) { return makeInt(i); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(short i) + ALWAYS_INLINE JSValue JSImmediate::from(short i) { return makeInt(i); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned short i) + ALWAYS_INLINE JSValue JSImmediate::from(unsigned short 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); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(unsigned i) + ALWAYS_INLINE JSValue JSImmediate::from(unsigned 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); } - 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); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(long long i) + ALWAYS_INLINE JSValue JSImmediate::from(long long i) { if ((i < minImmediateInt) | (i > maxImmediateInt)) - return noValue(); + return JSValue(); return makeInt(static_cast(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(i)); } - ALWAYS_INLINE JSValuePtr JSImmediate::from(double d) + ALWAYS_INLINE JSValue JSImmediate::from(double d) { const int intVal = static_cast(d); @@ -531,22 +492,22 @@ namespace JSC { 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); } - ALWAYS_INLINE double JSImmediate::toDouble(JSValuePtr v) + ALWAYS_INLINE double JSImmediate::toDouble(JSValue v) { ASSERT(isImmediate(v)); if (isIntegerNumber(v)) return intValue(v); -#if USE(ALTERNATE_JSIMMEDIATE) +#if USE(JSVALUE64) if (isNumber(v)) { - ASSERT(isDoubleNumber(v)); + ASSERT(isDouble(v)); return doubleValue(v); } #else @@ -560,75 +521,64 @@ namespace JSC { 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); } - 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); } - ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValuePtr v, uint32_t& i) + ALWAYS_INLINE bool JSImmediate::getTruncatedUInt32(JSValue v, uint32_t& 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()); @@ -638,194 +588,128 @@ namespace JSC { return false; } - inline bool JSValuePtr::getBoolean() const + inline bool JSValue::getBoolean() const { 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(val); - } - - inline uint32_t toUInt32(double val) - { - if (!(val >= 0.0 && val < 4294967296.0)) { - bool ignored; - return toUInt32SlowCase(val, ignored); - } - return static_cast(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()); } - inline bool JSValuePtr::isInt32Fast() const + inline bool JSValue::isInt32() const { return JSImmediate::isIntegerNumber(asValue()); } - inline int32_t JSValuePtr::getInt32Fast() const + inline int32_t JSValue::asInt32() const { - ASSERT(isInt32Fast()); + ASSERT(isInt32()); return JSImmediate::getTruncatedInt32(asValue()); } - inline bool JSValuePtr::isUInt32Fast() const + inline bool JSValue::isUInt32() const { return JSImmediate::isPositiveIntegerNumber(asValue()); } - inline uint32_t JSValuePtr::getUInt32Fast() const + inline uint32_t JSValue::asUInt32() const { - ASSERT(isUInt32Fast()); + ASSERT(isUInt32()); 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: - static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValuePtr v1, JSValuePtr v2) + static ALWAYS_INLINE bool canDoFastBitwiseOperations(JSValue v1, JSValue 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); } - 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); } - 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)); } - 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); } - 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)); } - static ALWAYS_INLINE bool canDoFastRshift(JSValuePtr v1, JSValuePtr v2) + static ALWAYS_INLINE bool canDoFastRshift(JSValue v1, JSValue 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); } - 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)); -#if USE(ALTERNATE_JSIMMEDIATE) +#if USE(JSVALUE64) return JSImmediate::makeValue(static_cast(static_cast(static_cast(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; } - 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); } - 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); } - 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); } - 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)); } - 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)); @@ -834,4 +718,6 @@ namespace JSC { } // namespace JSC +#endif // !USE(JSVALUE32_64) + #endif // JSImmediate_h